// 版权所有2011 Go作者。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// 由mkalldocs生成的代码。sh；不要编辑。
// 编辑其他文件中的文档，然后重新运行mkalldocs。生成这个。

// Go是一个管理Go源代码的工具。
// 
// 用法：
// 
// go<command>[arguments]
// 
// 命令为：
// 
// bug启动bug报告
// 构建编译包和依赖项
// 清除对象文件和缓存文件
// doc显示软件包或符号的文档
// env print Go环境信息
// 修复更新软件包以使用新的API 
// fmt gofmt（重新格式化）软件包源
// 通过处理源
// 获取对当前模块的依赖项并安装它们
// 安装编译并安装软件包和依赖项
// 列出软件包或模块
// 修改模块维护
// 工作区维护
// 运行编译并运行Go程序
// 测试软件
// 工具运行指定的Go工具
// version print Go version 
// vet report associated errors in packages 
// 
// 有关命令的详细信息，请使用“Go help<command>”。
// 
// 其他帮助主题：
// 
// buildconstraint build constraints 
// buildmode build modes 
// c在Go和c之间调用
// cache build and test cache 
// 环境变量
// filetype文件类型
// 开始。调整动作。mod file 
// gopath gopath环境变量
// gopath get legacy gopath go get 
// goproxy模块代理协议
// importpath导入路径语法
// modules modules，module versions，还有更多的
// 模块获取模块感知go获取
// 模块身份验证使用go。sum 
// 包包列表和模式
// 下载非公开代码的私有配置
// 测试标志
// 测试函数
// 与GOVCS一起控制版本控制的vcs 
// 
// 使用“go help<topic>”了解更多信息关于这个话题的信息。
// 
// 
// 启动错误报告
// 
// 用法：
// 
// go bug 
// 
// bug打开默认浏览器并启动新的错误报告。
// 该报告包含有用的系统信息。
// 
// 
// 编译包和依赖项
// 
// 用法：
// 
// go build[-o output][build flags][packages 
// 
// build编译由导入路径命名的包，
// 及其依赖项，但它没有安装结果。
// 
// 如果要构建的参数是。go文件来自单个目录，
// build将其视为指定单个包的源文件列表。编译包时，build会忽略以“\u test”结尾的文件。去吧。
// 
// 编译单个主包时，build将
// 生成的可执行文件写入以
// 命名的输出文件中第一个源文件（'go build ed.go rx.go'writes'ed'或'ed.exe'）
// 或源代码目录（'go build unix/sam'writes'sam'或'sam.exe'）。
// 。在编写Windows可执行文件时，会添加exe后缀。
// 
// 编译多个包或单个非主包时，
// build编译包，但放弃生成的对象，
// 仅用于检查包是否可以生成。
// 
// o标志强制build将生成的可执行文件或对象
// 写入指定的输出文件或目录，而不是
// 在最后两段。如果指定的输出是一个现有目录或
// 以斜杠或反斜杠结尾，则任何生成的可执行文件
// 都将写入该目录。
// 
// i标志安装作为目标的依赖项的包。
// 不推荐使用-i标志。编译后的包会自动缓存。
// 
// 构建标志由构建、清理、获取、安装、列表、运行、
// 和测试命令共享：
// 
// -a 
// 强制重建已更新的包。
// /-n 
// 打印命令，但不要运行它们。
// -p n 
// 可以并行运行的程序数，例如编译命令或测试二进制文件。
// 默认值为GOMAXPROCS，通常是可用的CPU数量。
// -种族
// 启用数据种族检测。
// 仅在linux/amd64、freebsd/amd64、darwin/amd64、darwin/arm64、windows/amd64、
// linux/ppc64le和linux/arm64上受支持（仅适用于48位VMA）。
// /-msan 
// 启用与内存消毒器的互操作。
// 仅在linux/amd64、linux/arm64和
// 上受支持，并且仅在Clang/LLVM作为主机C编译器时受支持。
// 在linux/arm64上，将使用饼图构建模式。
// asan 
// 启用与地址消毒器的互操作。
// 仅在linux/arm64、linux/amd64上支持。
// /-v 
// 在编译包时打印包的名称。
// -工作
// 打印临时工作目录的名称，退出时不要删除。打印命令。
// 
// -asmflags'[pattern=]arg list'
// /每次go tool asm调用时要传递的参数。
// -构建模式
// /要使用的构建模式。有关更多信息，请参阅“go help buildmode”。
// buildvcs 
// 是否在二进制文件上加盖版本控制信息的印章。默认情况下，如果主包
// 和包含它的主模块位于包含当前目录
// 的存储库中（如果有存储库），则版本控制信息将被标记为二进制。使用-buildvcs=false删除
// 忽略版本控制信息。
// -编译器名称
// 要在运行时使用的编译器名称。编译器（gccgo或gc）。
// /-gccgoflags'[pattern=]arg list'
// 用于传递每个gccgo编译器/链接器调用的参数。
// /-gcflags'[pattern=]arg list'
// 每次go工具编译调用时要传递的参数。
// installsuffix后缀
// 要在包安装目录的名称中使用的后缀，
// 以便将输出与默认版本分开。
// 如果使用-race标志，安装后缀将自动设置为race 
// 或者，如果显式设置，则在其后面附加_race。同样适用于-msan 
// 和-asan旗帜。使用需要非默认编译
// 标志的-buildmode选项也有类似的效果。
// /-ldflags'[pattern=]arg list'
// 每次调用go工具链接时要传递的参数。
// -linkshared 
// 将链接到以前的共享库的生成代码
// 使用-buildmode=shared创建。
// -mod模式
// 要使用的模块下载模式：只读、供应商或mod。
// 默认情况下，如果存在供应商目录，并且go版本在go中。mod 
// 为1.14或更高，go命令的作用就像设置了-mod=vendor一样。
// 否则，go命令的作用就好像设置了-mod=readonly一样。
// 参见https:
// /-modcacherw 
// 将新创建的目录保留在模块缓存中读写
// 而不是使其只读。
// /-modfile文件
// 在模块感知模式下，读取（可能还会写入）备用go。mod 
// 文件，而不是模块根目录中的文件。名为
// “go.mod”的文件必须仍然存在，才能确定模块根
// 目录，但无法访问该目录。当指定-modfile时，
// 交替进行。sum文件也被使用：它的路径是从
// /-modfile标志派生出来的，方法是修剪“.mod”扩展名并附加“.sum”。
// -覆盖文件
// 读取为构建操作提供覆盖的JSON配置文件。
// 该文件是一个JSON结构，带有一个名为“Replace”的字段，该字段将每个磁盘文件路径（一个字符串）映射到其备份文件路径，以便
// 构建将运行，就好像磁盘文件路径存在时，备份文件路径给出的内容是
// 一样，或者，如果备份文件路径为空，则磁盘文件路径不存在。对-overlay标志
// 的支持有一些局限性：重要的是，从
// include path外部包含的cgo文件必须与包含它们的Go包位于同一目录中，并且当二进制文件和测试分别通过Go run和Go test运行时，不会出现overlay。
// /-pkgdir dir 
// 从dir而不是通常的位置安装并加载所有软件包。
// 例如，当使用非标准配置构建时，
// 使用-pkgdir将生成的包保存在单独的位置。ABCFDG
// 构建约束的描述。
// （Go的早期版本使用空格分隔的列表，形式为
// 已被弃用，但仍被认可。）
// /-trimpath 
// 从生成的可执行文件中删除所有文件系统路径。
// 记录的文件名
// 将以模块开头，而不是绝对文件系统路径path@version（使用模块时）、
// 或普通导入路径（使用标准库或GOPATH时）。
// /-toolexec'cmd args'
// 用于调用vet和asm等工具链程序的程序。
// 例如，go命令将运行
// /'cmd args/path/to/asm<arguments For asm>，而不是运行asm。
// 将设置TOOLEXEC_IMPORTPATH环境变量，
// 为正在生成的包匹配'go list-f{{.IMPORTPATH}'。
// 
// asmlags、-gccgolfags、-gcflags和-ldflags标志接受
// 在构建期间传递给基础工具
// 的以空格分隔的参数列表。要在列表中的元素中嵌入空格，请将
// 用单引号或双引号括起来。参数列表可以是
// 前面有一个包模式和一个等号，这将
// 该参数列表的使用限制为构建与
// 该模式匹配的包（有关包
// 模式的描述，请参阅“go help packages”）。如果没有模式，参数列表仅适用于命令行上命名的
// 包。这些标志可以用不同的模式重复
// 以便为不同的包集指定不同的参数。如果一个包匹配
// 多个标志中给出的模式，则命令行上的最新匹配项将获胜。
// 例如，“go build-gcflags=-S fmt”打印反汇编
// 仅用于包fmt，而“go build-gcflags=all=-S fmt”
// 打印fmt及其所有依赖项的反汇编。
// 
// 有关指定包的更多信息，请参阅“go help packages”。
// 有关安装程序包和二进制文件的更多信息，请运行“go help gopath”。
// 有关在Go和C/C++之间调用的更多信息，请运行“Go help C”。
// 
// 注意：Build遵循某些约定，例如“go help gopath”中描述的那些约定。然而，并不是所有的项目都能遵循这些惯例。有自己的约定或使用
// 独立软件构建系统的安装可以选择使用较低级别的
// 调用，例如“go tool compile”和“go tool link”，以避免
// 构建工具的一些开销和设计决策。
// 
// 另请参见：安装、获取、清理。
// 
// 
// 删除目标文件和缓存文件
// 
// 用法：
// 
// go clean[清除标志][生成标志][包]
// 
// clean从包源目录中删除目标文件。
// go命令在临时目录中构建大多数对象，
// 因此go clean主要关注其他
// 工具或手动调用go build留下的对象文件。
// 
// 如果给定了包参数或设置了-i或-r标志，
// clean将从导入路径对应的每个
// 源目录中删除以下文件：
// 
// /\u obj/old object directory，左起Makefiles 
// /_test/old test目录，左起Makefiles 
// /_testmain目录。转到旧的gotest文件，Makefiles 
// test左边。从Makefiles 
// build中删除旧的测试日志。从Makefiles 
// /*中删除旧测试日志。[568ao]对象文件，来自Makefiles 
// 
// DIR（.exe）来自go build 
// DIR。测试（.exe）来自go测试-c 
// main文件（.exe）来自go构建main文件。去
// /*。因此，从列表中的SWIG 
// 
// 中，DIR代表
// 目录的最终路径元素，main file是目录中任何Go source 
// 文件的基本名称，在构建
// 包时不包括该文件。
// 
// i标志会导致clean删除相应已安装的
// archive或binary（go install将创建的内容）。
// 
// n标志导致clean打印它将执行的删除命令，但不运行它们。
// 
// r标志使clean递归应用于导入路径命名的包的所有依赖关系。
// 
// 在执行删除命令时，-x标志会导致clean打印删除命令。
// 
// cache标志导致clean删除整个go build缓存。
// 
// testcache标志导致clean使
// go build cache中的所有测试结果过期。
// 
// modcache标志会导致clean删除整个模块
// download cache，包括版本化的
// 依赖项的未打包源代码。
// 
// -fuzzcache标志导致clean删除存储在Go build 
// 用于模糊测试的缓存中的文件。模糊引擎缓存扩展
// 代码覆盖率的文件，因此删除它们可能会降低模糊的效率，直到找到提供相同覆盖率的新输入。这些文件是
// 不同于存储在testdata目录中的文件；clean不会删除
// 这些文件。
// 
// 有关生成标志的更多信息，请参阅“go help build”。
// 
// 有关指定包的更多信息，请参阅“go help packages”。
// 
// 
// 显示包裹或符号的文档
// 
// 用法：
// 
// go doc[文件标志][包裹]symbol[.methodOrField]]
// 
// Doc打印与由其
// 参数（包、常量、函数、类型、变量、方法或结构字段）标识的项相关联的文档注释
// 然后是“
// 该项”下的每一级项的单行摘要（包的包级声明、类型的方法、
// 等）。
// 
// Doc接受零个、一个或两个参数。
// 
// 不提供任何参数，即当作为
// 
// go doc 
// 
// 运行时，它在当前目录中打印包的包文档。
// 如果包是命令（包主），则除非提供了-cmd标志，否则将从演示文稿中删除包
// 的导出符号。
// 
// 当使用一个参数运行时，该参数将被视为Go语法，如
// 待记录项的表示形式。参数的选择取决于GOROOT和GOPATH中安装的内容，以及参数的形式，这是其中的一个：
// 
// 
// go doc<pkg>
// go doc<sym>[.<methodOrField>]
// go doc[<pkg>]<sym>[.<methodOrField>]
// go doc[<pkg>][<sym>]<methodOrField>
// 
// 此列表中与参数匹配的第一项是打印文档
// 的项。（参见下面的示例。）但是，如果参数以大写字母
// 开头，则假定它标识当前目录中的符号或方法。
// 
// 对于软件包，扫描顺序在词汇上以广度优先顺序确定。
// 也就是说，提供的包与搜索匹配，并且最接近
// 根，在其层次结构的级别上，在词汇上是第一位的。GOROOT树是
// 在GOPATH之前始终进行完整扫描。
// 
// 如果没有指定或匹配包，则选择当前
// 目录中的包，因此“go doc Foo”显示当前包中符号Foo的文档。
// 
// 包路径必须是限定路径或
// 路径的正确后缀。go工具通常的包机制不适用：包路径
// 类似的元素。和不是由go doc实现的。
// 
// 当使用两个参数运行时，第一个是包路径（完整路径或后缀），
// 第二个是符号，或带有方法或结构字段的符号：
// 
// go doc<pkg><sym><methodOrField>]
// 
// 在所有形式下，当匹配符号时，参数中的小写字母与
// 两者都匹配，但大写字母完全匹配。这意味着，如果不同的符号有不同的大小写，那么包中可能有多个小写参数匹配。如果出现这种情况，将打印所有匹配项的文档。
// 
// 示例：
// go doc 
// 显示当前包的文档。
// go doc Foo 
// 在当前包中显示Foo的文档。
// （Foo以大写字母开头，因此它不能与
// a包路径匹配。）
// go doc encoding/json 
// 显示编码/json包的文档。
// go doc json 
// /编码简写/json。
// go doc json。Number（或go doc json.Number）
// 显示json的文档和方法摘要。数字
// go doc json。数字Int64（或go doc json.number.Int64）
// 显示json的文档。Number的Int64方法。
// go doc cmd/doc 
// 为doc命令显示包文档。
// go doc-cmd cmd/doc 
// 在doc命令中显示包文档和导出的符号。
// go文档模板。新的
// 显示html/模板新功能的文档。
// （html/template在词汇上位于text/template之前）
// go doc text/template。新的#单参数
// 显示文本/模板新函数的文档。
// go doc text/template new#两个参数
// 显示text/template新函数的文档。
// 
// 至少在当前树中，这些调用都会打印json的
// 文档。解码器的解码方法：
// 
// go doc json。解码器。解码
// go doc json。解码器。解码
// go doc json。解码
// cd go/src/encoding/json；go doc decode 
// 
// 标志：
// -所有
// 显示包的所有文档。
// /-c 
// 匹配符号时请注意大小写。
// /-cmd 
// 将命令（包main）视为常规包。
// 否则，当显示包的顶级文档时，包main的导出符号被隐藏。
// -缩写
// /每个符号用一行表示。
// /-src 
// 显示符号的完整源代码。这将显示其声明和定义的完整Go源，例如函数定义（包括
// 正文）、类型声明或封闭常量
// 块。因此，输出可能包括未报告的
// 详细信息。
// /-u 
// 显示未报告和导出的
// 符号、方法和字段的文档。
// 
// 
// 打印围棋环境信息
// 
// 用法：
// 
// Go env[-json][u][w][var…]
// 
// Env打印Go环境信息。
// 
// 默认情况下，env将信息打印为shell脚本
// （在Windows上为批处理文件）。如果一个或多个变量
// 名称作为参数提供，env将在其自己的行上打印每个命名变量的值。
// 
// json标志以json格式而不是作为shell脚本打印环境。
// 
// u标志需要一个或多个参数，并取消设置
// 命名环境变量的默认设置
// 如果已使用“go env-w”设置。
// 
// w标志需要
// form NAME=VALUE的一个或多个参数，并将命名环境变量的默认设置
// 更改为给定值。
// 
// 有关环境变量的更多信息，请参阅“go help environment”。
// 
// 
// 更新软件包以使用新的API 
// 
// 用法：
// 
// go fix[-fix list][packages 
// 
// fix在导入路径指定的软件包上运行go fix命令。
// 
// fix标志设置要运行的修复程序的逗号分隔列表。
// 默认为所有已知修复。
// /（其值被传递到“go tool fix-r”。）
// 
// 有关修复的更多信息，请参阅“go doc cmd/fix”。
// 有关指定程序包的更多信息，请参阅“go help packages”。
// 
// 要使用其他选项运行修复程序，请运行“go tool fix”。
// 
// 另见：去fmt，去兽医。
// 
// 
// Gofmt（重新格式化）包源
// 
// 用法：
// 
// go fmt[-n][x][packages]
// 
// fmt通过导入路径在名为
// 
// 有关gofmt的更多信息，请参阅“go doc cmd/gofmt”。
// 有关指定包的更多信息，请参阅“go help packages”。
// 
// n标志打印将要执行的命令。
// 执行命令时，-x标志会打印命令。
// 
// mod标志的值设置要使用的模块下载模式
// 只读或供应商。有关更多信息，请参阅“go help模块”。
// 
// 要使用特定选项运行gofmt，请运行gofmt本身。
// 
// 另请参见：修复，检查。
// 
// 
// 通过处理源代码生成Go文件
// 
// 用法：
// 
// Go Go Generate[-run regexp][n][v][x][build flags][file.Go…| packages 
// 
// 在现有
// 文件中生成由指令描述的运行命令。这些命令可以运行任何进程，但目的是创建或更新Go源文件。
// 
// Go生成永远不会通过Go构建、Go测试、
// 等自动运行。它必须显式运行。
// 
// Go generate扫描文件中的指令，这些指令是
// 表单
// 
// /Go:generate命令参数。。。
// 
// （注意：“/go”中没有前导空格和空格），其中命令
// 是要运行的生成器，对应于可在本地运行的可执行文件
// 。它必须位于shell路径
// （gofmt）、完全限定路径（/usr/you/bin/mytool）或
// 命令别名中，如下所述。
// 
// 注意go generate不会解析文件，因此在注释或多行字符串中看起来像指令的行将被视为指令。
// 
// 该指令的参数是空格分隔的标记或
// 作为单个
// 运行时的参数。
// 
// 带引号的字符串使用Go语法，并在执行前进行评估；
// 带引号的字符串将作为单个参数显示给生成器。
// 
// 要向人类和机床传达生成的代码，
// 生成的源代码应该有一行匹配以下
// 正则表达式（Go语法）：
// 
// 生成的代码。*不要编辑\.$
// 
// 此行必须出现在文件中第一个非注释、非空白的
// 文本之前。
// 
// Go generate在运行生成器时设置了几个变量：
// 
// /$GOARCH 
// 执行体系结构（arm、amd64等）
// 执行操作系统（linux、windows等）
// /$GOLINE 
// 源文件中指令的行号。
// /$GOPACKAGE 
// 包含指令的文件包的名称。
// /$美元
// 一个美元符号。
// 
// 除了变量替换和带引号的字符串求值之外，没有对命令
// 行执行“globbing”等特殊处理。
// 
// 作为运行命令之前的最后一步，对任何带有字母数字名称的
// 环境变量（如$GOFILE或
// /$HOME）的任何调用都会在整个命令行中展开。
// 变量扩展的语法在所有操作系统上都是$NAME。由于
// 的求值顺序，变量甚至在引用的
// 字符串中也会展开。如果未设置变量名，$NAME将扩展为
// 空字符串。
// 
// 形式的指令，
// 
// /go:generate-command xxx args。。。
// 
// 仅为该源文件的其余部分指定，
// 字符串xxx表示由参数标识的命令。此
// 可用于创建别名或处理多字生成器。例如，
// 
// /go:generate-command foo go tool foo 
// 
// 指定命令“foo”代表生成器
// “go tool foo”。
// 
// 按照命令行上给出的顺序生成进程包，
// 一次一个。如果命令行列出。go文件来自一个目录，
// 它们被视为一个包。在包内，generate按文件名顺序处理包中的
// 源文件，每次一个。在源文件中，generate按生成器在文件中出现的顺序运行生成器，一次一个。go generate工具还设置了build 
// 标记“generate”，以便go generate可以检查文件，但在构建过程中忽略了
// 标记。
// 
// 对于包含无效代码的包，请使用
// valid package子句生成仅处理源文件。
// 
// 如果任何生成器返回错误退出状态，“go generate”将跳过该包的所有进一步处理。
// 
// 生成器在包的源目录中运行。
// 
// Go generate接受一个特定标志：
// 
// /-run=”“
// 如果非空，则指定一个正则表达式来选择其完整原始源文本（不包括
// 指令。
// 任何尾随空格和最后换行）与
// 
// 它还接受标准的构建标志，包括-v、-n和-x。
// 在处理包和文件时，-v标志会打印它们的名称。
// n标志打印将要执行的命令。
// 执行命令时，-x标志会打印命令。
// 
// 有关生成标志的更多信息，请参阅“go help build”。
// 
// 有关指定包的更多信息，请参阅“go help packages”。
// 
// 
// 将依赖项添加到当前模块并安装它们
// 
// 用法：
// 
// go get[-t][u][v][build flags][packages]
// 
// get将其命令行参数解析为特定模块版本的包，
// 更新开始。mod需要这些版本，并将源代码下载到
// 模块缓存中。
// 
// 为包添加依赖项或将其升级到最新版本：
// 
// 获取示例。com/pkg 
// 
// 将包升级或降级到特定版本：
// 
// 获取示例。com/pkg@v1.2.3
// 
// 删除对模块的依赖并降级需要它的模块：
// 
// 去获取示例。com/mod@none
// 参见https:
// 
// 在Go的早期版本中，“Go get”用于构建和安装软件包。
// 现在，“go-get”专门用于调整go中的依赖项。国防部go install’
// 可以用来生成和安装命令。指定版本后，
// /'go install'将在模块感知模式下运行，并忽略go。当前目录中的mod文件。例如：
// 
// go install example。com/pkg@v1.2.3
// 转到安装示例。com/pkg@latest
// 
// 请参阅“go help install”或https:
// 
// “go get”接受以下标志。ABCFDG
// 
// u标志指示get更新提供依赖关系的模块
// 命令行上命名的包，以便在可用时使用更新的次要版本或补丁
// 版本。
// 
// u=patch标志（而不是-u patch）也指示get更新依赖项，但更改默认值以选择补丁发布。
// 
// 当-t和-u标志一起使用时，get也将更新
// 测试依赖项。
// 
// x标志在命令执行时打印命令。这对于从存储库直接下载模块时调试版本控制命令非常有用。
// 
// 有关模块的更多信息，请参阅https:
// 
// 有关指定包的更多信息，请参阅“go help packages”。
// 
// 本文描述了get使用模块管理源代码的行为
// 代码和依赖项。相反，如果go命令是在GOPATH 
// 模式下运行的，那么get的标志和效果的细节会发生变化，“go help get”也会发生变化。
// 请参阅“go help gopath get”。
// 
// 另请参见：开始构建、开始安装、开始清理、开始修改。
// 
// 
// 编译和安装程序包和依赖项
// 
// 用法：
// 
// 安装[build flags][packages 
// 
// 安装编译和安装按导入路径命名的程序包。
// 
// 可执行文件安装在GOBIN环境
// 变量指定的目录中，如果未设置GOPATH 
// 环境变量，该变量默认为$GOPATH/bin或$HOME/go/bin。$GOROOT 
// 中的可执行文件安装在$GOROOT/bin或$GOTOOLDIR中，而不是$GOBIN中。
// 
// 如果参数有版本后缀（如@latest或@v1.0.0），“go install”
// 以模块感知模式构建包，忽略go。当前
// 目录或任何父目录（如果有）中的mod文件。这对于
// 在不影响主模块依赖关系的情况下安装可执行文件非常有用。
// 为了消除在构建中使用哪些模块版本的歧义，
// 参数必须满足以下约束：
// 
// -参数必须是包路径或包模式（带“…”通配符）。
// 它们不能是标准包（如fmt）、元模式（std、cmd、
// 全部）或相对或绝对文件路径。
// 
// -所有参数必须具有相同的版本后缀。不同的查询不是
// 允许，即使它们指的是同一版本。
// 
// -所有参数必须引用同一模块中同一版本的包。
// 
// -包路径参数必须引用主包。模式参数
// 将仅与主包匹配。
// 
// -没有模块被视为“主”模块。如果命令行中包含
// 包的模块有一个go。mod file，它不能包含会导致其解释与主模块不同的
// 指令（替换和排除）。该模块不得要求
// 更高版本的自身。
// 
// -任何模块中都不使用供应商目录。（供应商目录不是
// 包含在“go install”下载的模块zip文件中。）
// 
// 如果参数没有版本后缀，“go install”可以在
// 模块感知模式或GOPATH模式下运行，具体取决于GO111模块环境
// 变量和go的存在。mod文件。有关详细信息，请参阅“go帮助模块”。
// 如果启用了模块感知模式，“go install”将在主
// 模块的上下文中运行。
// 
// 当禁用模块感知模式时，其他软件包将安装在
// 目录$GOPATH/pkg/$GOOS_$GOARCH中。启用模块感知模式时，
// 会生成并缓存其他软件包，但不会安装。
// 
// i标志也安装命名包的依赖项。
// 不推荐使用-i标志。编译后的包会自动缓存。
// 
// 有关构建标志的更多信息，请参阅“go help build”。
// 有关指定软件包的更多信息，请参阅“go help packages”。
// 
// 另请参见：开始构建，开始获取，开始清理。
// 
// 
// 列出软件包或模块
// 
// 用法：
// 
// go List[-f格式][json][m][List标志][构建标志][软件包]
// 列出指定的软件包，每行一个。
// 最常用的标志是-f和-json，它们控制为每个包打印的输出的形式
// 。下面记录的其他列表标志
// 控制更具体的细节。
// 
// 默认输出显示包导入路径：
// 
// 字节
// 编码/json 
// github。com/gorilla/mux 
// golang。org/x/net/html 
// 
// f标志使用包模板的
// 语法指定列表的替代格式。默认输出相当于
// to-f'{{.ImportPath}'。传递给模板的结构是：
// 
// type Package struct{
// Dir string
// ImportPath string
// ImportComment string
// Name string PACK Name 
// Doc stringkage文档字符串
// 目标字符串
// Shlib string
// Goroot bool
// 标准bool
// Stale bool
// StaleReason string
// Root string
// ConflictDir string
// binary only bool
// package仅用于命名测试
// Export string
// BuildID string
// Module Module Module
// Match[]string
// depoly bool
// 
// 
// GoFiles[]string
// CgoFiles[]string
// 编译文件[]字符串
// /IgnoredGoFiles[]string
// IgnoredOtherFiles[]字符串
// CFiles[]string
// CXX文件[]字符串
// MFiles[]字符串
// HFiles[]字符串
// FFiles[]字符串
// SFiles[]string
// SwigFiles[]字符串
// SwigCXXFiles[]string
// SysoFiles[]string
// TestGoFiles[]字符串
// XTestGoFiles[]string/\u test。go:包外文件
// 
// /嵌入文件
// /嵌入模式[]字符串
// /嵌入文件[]字符串
// TestEmbedPatterns[]字符串
// XTestEmbedPatterns[]string
// XTestEmbedFiles[]string
// /Cgo指令
// cgoflags[]string
// /依赖项信息
// /导入[]字符串
// ImportMap[string]字符串
// Deps[]字符串
// TestImports[]string
// XTestImports[]string
// 
// 
// 不完整的布尔
// 错误*包错误
// deperrors[]*PackageError
// }
// 
// /存储在供应商目录中的程序包报告一个导入路径，该路径包含指向供应商目录的
// 路径（例如，“d/vendor/p”而不是“p”），
// 以便ImportPath唯一标识包的给定副本。
// 导入、Deps、TestImports和XTestImports列表也包含这些
// 扩展的导入路径。见戈朗。org/s/go15vendor了解更多关于vendoring的信息。
// 
// 如果有错误信息，是
// 
// type PackageError struct{
// ImportStack[]string
// Pos string
// Err string
// 
// 
// 模块信息是一个模块结构，在下面列表-m的讨论
// 中定义。
// 
// 模板函数“join”调用字符串。参加
// 
// 模板函数“context”返回构建上下文，定义为：
// 
// type Context struct{
// GOARCH string
// GOOS string
// GOROOT string
// GOPATH string
// CgoEnabled bool
// 编译器字符串
// BuildTags[]字符串
// ToolTags[]字符串
// ReleaseTags[]字符串
// InstallSuffix string
// }
// 
// 有关这些字段含义的更多信息，请参阅文档
// ，了解go/build包的上下文类型。
// 
// json标志使包数据以json格式打印，而不是使用模板格式。
// 
// compiled标志使列表将compiledProfiles设置为提供给编译器的Go源文件
// 文件。通常这意味着它会重复GoFiles中列出的文件，然后还会添加通过处理CG文件和SwigFiles生成的Go代码。导入列表包含从GoFiles和CompiledProfiles的所有导入的联合。
// 
// deps标志使列表不仅遍历命名包
// ，还遍历它们的所有依赖项。它以深度优先的后序
// 遍历方式访问它们，因此一个包只在其所有依赖项之后列出。
// 未在命令行中明确列出的包将把DepOnly 
// 字段设置为true。
// 
// e标志改变了对错误包的处理，即那些无法找到或格式不正确的包。默认情况下，list命令
// 会为每个错误的包打印一个错误到标准错误，而
// 会在通常的打印过程中忽略这些包。
// 使用-e标志，list命令从不将错误打印到标准
// 错误，而是使用通常的
// 打印来处理错误的包。错误的包将有一个非空的ImportPath和一个非空的
// 错误字段；其他信息可能缺失，也可能不缺失
// /（归零）。
// 
// 导出标志使列表将导出字段设置为包含给定包的最新导出信息的
// 文件的名称。
// 
// find标志使列表识别命名包，但不识别
// 解决它们的依赖关系：导入和Deps列表将为空。
// 
// test标志使列表不仅报告命名的包
// 而且报告它们的测试二进制文件（对于带有测试的包），以便向
// 源代码分析工具准确地传达测试二进制文件是如何构造的。
// 报告的测试二进制文件的导入路径是
// 该包后跟一个“.test”后缀，如“math/rand.test”。
// 在构建测试时，有时需要为该测试重建特定的
// 依赖项（最常见的是已测试的
// 包本身）。为特定测试二进制文件重新编译的包的报告导入路径
// 后跟一个空格和
// 括号中的测试二进制文件的名称，如“math/rand[math/rand.test]”
// 或“regexp[sort.test]”。ForTest字段也被设置为被测试包的名称
// （前面的
// examples中的“math/rand”或“sort”）。
// 
// 目录、目标、Shlib、根目录、冲突目录和导出文件路径
// 都是绝对路径。
// 
// 默认情况下，列表GoFiles、CgoFiles等包含目录中的文件名
// （即相对于目录的路径，而不是绝对路径）。
// 使用-compiled and-test标志
// 是指生成的Go源文件的缓存副本的绝对路径。
// 虽然它们是Go源文件，但路径可能不会以“.Go”结尾。
// 
// m标志使列表列出模块而不是包。
// 
// 在列出模块时，-f标志仍然指定应用于Go结构的格式模板
// ，但现在是一个模块结构：
// 
// 类型模块结构{
// 路径字符串
// 版本字符串
// 版本[]字符串
// 替换*模块
// 时间*时间。时间
// 更新*模块
// 主布尔
// 间接bool
// Dir string
// GoMod string
// GoVersion string
// Retracted string
// 错误*模块错误
// }
// 
// 类型ModuleError struct{
// 错误字符串
// }
// 
// 如果
// 模块在模块缓存中，或者如果使用了-modfile标志。
// 
// 默认输出是打印模块路径，然后打印
// 有关版本和替换（如果有）的信息。
// 例如，“go list-m all”可能会打印：
// 
// my/main/module 
// golang。org/x/text v0。3.0=>/tmp/text 
// rsc。io/pdf v0。1.1 
// 
// 模块结构有一个字符串方法，用于格式化此
// 输出行，因此默认格式相当于
// to-f'{.String}'。
// 
// 注意，当模块被替换时，其替换字段
// 描述替换模块，其Dir字段设置为
// 替换的源代码（如果存在）。（也就是说，如果Replace 
// 非nil，则Dir设置为Replace.Dir，无法访问
// 被替换的源代码。）
// 
// u标志添加有关可用升级的信息。
// 当给定模块的最新版本比当前版本更新时，list-u将模块的更新字段
// 设置为有关较新模块的信息。list-u还将设置
// 如果当前版本被收回，则模块的收回字段。
// 该模块的String方法表示
// 在当前版本之后的括号中格式化较新版本的可用升级。
// 如果一个版本被收回，字符串“（retracted）”将跟随它。
// 例如，“go list-m-u all”可能会打印：
// 
// my/main/module 
// golang。org/x/text v0。3.0[v0.4.0]=>/tmp/text 
// rsc。io/pdf v0。1.1（收回）[v0.1.2]
// 
// （对于工具，“go list-m-u-json all”可能更便于解析。）
// 
// 版本标志使列表将模块的版本字段
// 设置为该模块所有已知版本的列表，按照
// 从早到晚的语义版本控制进行排序。该标志还更改了默认输出格式
// 以显示模块路径，后跟
// 以空格分隔的版本列表。
// 
// retracted标志使列表报告有关已撤回的
// 模块版本的信息。当-retracted与-f或-json一起使用时，retracted 
// 字段将被设置为一个字符串，解释版本被撤回的原因。
// 该字符串取自
// 模块的go中关于RECTract指令的注释。mod文件。当-retracted与-versions一起使用时，retracted 
// 版本与未retracted版本一起列出。缩回的
// 标志可以与-m一起使用，也可以不与-m一起使用。
// 
// list-m的参数被解释为模块列表，而不是包。
// 主模块是包含当前目录的模块。
// 活动模块是主模块及其依赖项。
// 没有参数，list-m显示主模块。
// 对于参数，list-m显示参数指定的模块。
// 任何活动模块都可以通过其模块路径指定。
// 特殊模式“all”指定所有活动模块，首先是主
// 模块，然后是按模块路径排序的依赖项。
// 包含“…”的模式指定
// 模块路径与模式匹配的活动模块。
// 表单的查询path@version指定该查询的结果
// 不限于活动模块。
// 有关模块查询的更多信息，请参阅“go help modules”。
// 
// 模板函数“module”接受单个字符串参数
// 该参数必须是模块路径或查询，并将指定的
// 模块作为模块结构返回。如果发生错误，结果将是带有非零错误字段的模块结构。
// 
// 有关生成标志的更多信息，请参阅“go help build”。
// 
// 有关指定包的更多信息，请参阅“go help packages”。
// 
// 有关模块的更多信息，请参阅https:
// 
// 
// 模块维护
// 
// Go mod提供对模块操作的访问。
// 
// 请注意，所有go命令都内置了对模块的支持，而不仅仅是“go mod”。例如，日常添加、删除、升级、
// 和降级依赖项都应该使用“go get”完成。
// 有关模块功能的概述，请参阅“go help modules”。
// 
// 用法：
// 
// go mod<command>[arguments]
// 
// 命令是：
// 
// 下载模块到本地缓存
// 编辑go。mod from tools或scripts 
// 图形打印模块需求图
// 初始化当前目录中的新模块
// 整理添加缺失和删除未使用的模块
// 供应商制作依赖项的供应商副本
// 验证依赖项是否具有预期内容
// 为什么解释为什么需要包或模块
// 
// 有关命令的详细信息，请使用“go help mod<command>”。
// 
// 将模块下载到本地缓存
// 
// 用法：
// 
// go mod Download[-x][json][modules]
// 
// 下载指定的模块，其中可以是模块模式选择
// 主模块的依赖项或表单的模块查询path@version.
// 
// 不带任何参数，下载适用于构建和测试
// 主模块中的包：主
// 模块明确要求的模块，如果它在'go 1.17'或更高版本，或者所有过渡要求的模块
// 如果在'go 1.16'或更低版本。
// 
// 在普通
// 执行过程中，go命令会根据需要自动下载模块。“go mod download”命令主要用于预填充
// 本地缓存或计算go模块代理的答案。默认情况下，下载不会将任何内容写入标准输出。它可以将进度
// 消息和错误打印为标准错误。
// 
// json标志使download将json对象序列
// 打印到标准输出，描述每个下载的模块（或故障），
// 对应于这个Go结构：
// 
// 类型模块结构{
// 路径字符串
// 版本字符串
// 错误字符串
// 信息字符串
// GoMod string
// Zip字符串
// Dir string
// Sum string
// GoModSum string
// }
// 
// x标志导致下载打印下载执行的命令。
// 参见https:
// 参见https:
// 
// 
// 编辑开始。mod from tools或scripts 
// 
// 用法：
// 
// go mod edit[editing flags][fmt |-print |-json][go.mod 
// 
// edit为编辑go提供了一个命令行界面。mod，
// 主要用于工具或脚本。上面写着“只去”。摩登派青年
// 它不查找有关所涉及模块的信息。
// 默认情况下，编辑读取和写入go。主模块的mod文件
// 但在编辑标志后可以指定不同的目标文件。
// 
// 编辑标志指定了一系列编辑操作。
// 
// fmt标志将重新设置go。修改文件而不做其他更改。
// 使用或重写go的任何其他修改也暗示了这种重新格式化。mod文件。唯一需要此标志的时间是，如果没有指定其他
// 标志，如“go mod edit-fmt”中所述。
// 
// module标志更改模块的路径（go.mod文件的模块行）。
// 
// The-require=path@versionand-droprequire=path flags 
// 在给定模块路径和版本上添加和删除需求。
// 请注意，-require会覆盖path上的任何现有要求。
// 这些标志主要用于理解模块图的工具。
// 用户应该更喜欢“go get”path@version或者“去拿”path@none“，
// 这让其他人走了。根据需要进行mod调整，以满足
// 其他模块施加的约束。
// 
// The-exclude=path@version和-排除=path@version标志
// 添加和删除给定模块路径和版本的排除。
// 注意-exclude=path@version如果排除已经存在，则为不可操作。
// 
// replace=old[@v]=new[@v]标志添加了对给定
// 模块路径和版本对的替换。如果@v在old@v省略，增加了一个左侧没有版本的
// 替换，将
// 应用于旧模块路径的所有版本。如果@v在new@v省略，
// 新路径应该是本地模块根目录，而不是模块
// 路径。请注意，-replace会覆盖旧[@v]的任何冗余替换，
// 因此省略@v将删除特定版本的现有替换。
// 
// dropreplace=old[@v]标志会删除给定
// 模块路径和版本对的替换。如果省略@v，则删除左侧不带
// 的替换版本。
// 
// 在给定版本上添加和删除
// 收回-retract=version和-dropretract=version标志。该版本可以是单个版本
// 如“v1.2.3”或封闭区间，如“[v1.1.0，v1.1.9]”。请注意，如果撤回已经存在，则
// /-retract=版本是不可操作的。
// 
// 可以重复-require、-droprequire、-exclude、-dropexclude、-replace、
// /-dropreplace、-retract和-dropretract编辑标志，
// 并按给定顺序应用更改。
// 
// -go=version标志设置预期的go语言版本。
// 
// print标志将打印最终的go。mod的文本格式，而不是
// 写回去。摩登派青年
// 
// json标志将打印最终的go。mod文件为JSON格式，而不是
// 将其写回go。摩登派青年JSON输出对应于以下Go类型：
// 
// type Module struct{
// 路径字符串
// 版本字符串
// /}
// 
// 类型GoMod struct{
// 模块ModPath 
// Go string 
// 要求[]要求
// 排除[]模块
// 替换[]替换
// }
// 
// type ModPath struct{
// Path string 
// /弃用字符串
// }
// 
// /type Require struct struct{
// 路径字符串
// 版本字符串
// 间接布尔
// }
// 
// 类型替换结构{
// 旧模块
// 新模块
// }
// 
// 类型收回结构{
// 低位字符串
// 高位字符串
// 基本原理字符串
// /}
// 
// 表示单个版本（非间隔）的Retract条目将具有
// 将“低位”和“高位”字段设置为相同的值。
// 
// 注意，这只描述了围棋。mod文件本身，而不是其他模块
// 间接引用。对于可用于构建的完整模块集，
// 使用'go list-m-json all'。
// 参见https:
// 
// 
// 打印模块需求图
// 
// 用法：
// 
// go mod graph[-go=version]
// 
// graph以文本形式打印模块需求图（使用替换项）
// 。输出中的每一行都有两个空格分隔的字段：模块
// 和它的一个需求。每个模块都标识为
// /格式的字符串path@version，除了主模块，它没有@version后缀。
// 
// go标志会导致graph报告模块图由
// 给定的go版本加载，而不是go中“go”指令
// 指示的版本。mod文件。
// 参见https:
// 
// 
// 初始化当前目录中的新模块
// 
// 用法：
// 
// go mod init[模块路径]
// 
// 初始化并写入新go。mod file在当前目录中，在
// effect中创建一个在当前目录下扎根的新模块。开始吧。mod file 
// 必须不存在。
// 
// Init接受一个可选参数，即新模块的模块路径。如果省略了
// 模块路径参数，init将尝试在中使用导入注释推断模块路径
// 。go文件、vendoring工具配置文件（如
// Gopkg.lock）和当前目录（如果在GOPATH中）。
// 
// 如果存在销售工具的配置文件，init将尝试从中导入模块需求。
// 参见https:
// 
// 
// 添加缺失的模块并删除未使用的模块
// 
// 用法：
// 
// go mod tidy[-e][v][go=version][compat=version]
// 
// tidy确保运行。mod与模块中的源代码匹配。
// 它添加构建当前模块的
// 包和依赖项所需的任何缺失模块，并删除
// 不提供任何相关包的未使用模块。它还会添加任何缺少的条目
// go。求和并删除任何不必要的内容。
// 
// v标志导致tidy打印有关已删除模块的信息
// to standard error。
// 
// 尽管在加载包时遇到错误，但-e标志会导致tidy尝试继续。
// 
// go标志导致tidy更新go中的'go'指令。mod 
// 将文件更改为给定版本，这可能会更改哪个模块依赖项
// 保留为go中的明确要求。mod文件。
// （Go版本1.17及更高版本保留了更多要求，以支持延迟模块加载。）
// 
// compat标志保留所示主要go版本中
// “go”命令所需的任何额外校验和，以成功加载
// /模块图，如果该版本的
// /'go'命令将从另一个模块
// /'版本加载任何导入的包，则会导致tidy出错。默认情况下，tidy的行为就像-compat标志被设置为
// 版本，在go中的“go”指令指示的版本之前。mod 
// 文件。
// 参见https:
// 
// 
// 制作依赖项的供应商副本
// 
// 用法：
// 
// go mod vendor[-e][v][o outdir]
// 
// 供应商重置主模块的供应商目录，以包含所有软件包
// 需要构建和测试所有主模块模块的包。
// 它不包括用于出售软件包的测试代码。
// 
// v标志导致供应商将供应商提供的
// 模块和包的名称打印为标准错误。
// 
// 尽管在加载包时遇到错误，但-e标志会导致供应商尝试继续。
// 
// o标志导致供应商在给定的
// 路径而不是“供应商”创建供应商目录。go命令只能使用模块根目录中名为“vendor”的vendor目录
// 因此该标志主要用于其他工具。
// 
// 参见https:
// 
// 
// 验证依赖项是否具有预期的内容
// 
// 用法：
// 
// 转到mod Verify 
// 
// 验证当前模块
// 的依赖项是否存储在本地下载的源缓存中，下载后未被修改。如果所有模块都未修改，
// 验证将打印“所有模块已验证”否则，它会报告哪些
// 模块已更改，并导致“go mod”以
// 非零状态退出。
// 参见https:
// 
// 
// 解释为什么需要软件包或模块
// 
// 用法：
// 
// go mod why[-m][vendor]软件包。。。
// 
// 为什么在导入图中显示从主模块到
// 列出的每个包的最短路径。如果给出了-m标志，为什么要将
// 参数视为模块列表，并在每个模块的
// 中查找到任何包的路径。
// 
// 默认情况下，为什么要查询与“go list all”匹配的包图，
// 其中包括对可访问包的测试。-vendor标志导致
// 排除依赖项测试。
// 
// 输出是一系列的节，每个包或模块对应一节命令行上的名称
// 用空行分隔。每一节都以注释行“#package”或“#module”开头，给出目标
// package或module。后续几行给出了导入
// 图的路径，每行一个包。如果包或模块不是从主模块引用的
// 节将显示一个单独的
// 括号注释，指示该事实。
// 
// 例如：
// 
// /$go mod why golang。org/x/text/language golang。org/x/text/encoding 
// /#golang。org/x/text/language 
// rsc。io/引用
// rsc。io/采样器
// golang。org/x/text/language 
// 
// /#golang。org/x/text/encoding 
// （主模块不需要golang.org/x/text/encoding包）
// $
// /
// 请参见https:
// 
// 
// 工作区维护
// 
// 工作提供对工作区操作的访问。
// 
// 请注意，对工作区的支持内置于许多其他命令中，而不是
// 只需“开始工作”。
// 
// 有关go模块系统的信息，请参阅“go帮助模块”，
// 工作区是其中的一部分。
// 参见https:
// 工作区的深入参考。
// 参见https:
// 教程。
// 
// 工作区由go指定。使用“use”指令指定一组
// 模块目录的工作文件。这些模块被go命令用作
// 根模块，用于构建和相关操作。
// 未指定要使用的模块的工作区不能用于从本地模块生成
// 版本。快走。工作文件是面向行的。每一行都有一个指令
// 由关键字和参数组成。例如：
// 
// go 1.18 
// 
// use/foo/bar 
// 使用/baz 
// 
// 替换示例。com/foo v1。2.3=>示例。com/bar v1。4.5 
// 
// 可以从相邻行中分解出前导关键字来创建块，
// 类似于Go导入。
// 
// /use（
// /foo/bar 
// /baz 
// ）
// 
// /use指令指定要包含在工作区的
// 主模块集中的模块。use指令的参数是包含模块go的目录
// 。mod文件。
// 
// go指令指定写入文件的go版本。
// 工作区的语义可能会在将来发生更改，这些更改可能会受此版本的控制，但目前指定的版本
// 无效。
// 
// replace指令的语法与
// go中的replace指令相同。mod文件，优先于go中的替换。mod文件。它是
// 主要用于覆盖不同工作区中冲突的替换
// 模块。
// 
// 要确定go命令是否在工作区模式下运行，请使用
// go env GOWORK命令。这将指定正在使用的工作区文件
// 。
// 
// 用法：
// 
// 开始工作<command>[参数]
// 
// 命令是：
// 
// 编辑开始。使用工具或脚本
// 初始化工作区文件
// 将同步工作区构建列表同步到模块
// 使用将模块添加到工作区文件
// 
// 使用“go help work<command>”了解有关命令的更多信息。
// 
// 编辑开始。使用工具或脚本工作
// 
// 用法：
// 
// go work编辑[编辑标志][go.work]
// 
// edit为编辑go提供命令行界面。工作，
// 主要由工具或脚本使用。它只写着“开始”。工作
// 它不查找有关所涉及模块的信息。
// 如果未指定任何文件，Edit将查找go。当前
// 目录及其父目录中的工作文件
// 
// 编辑标志指定了一系列编辑操作。
// 
// fmt标志将重新设置go。不做其他更改的工作文件。
// 使用或重写go的任何其他修改也暗示了这种重新格式化。mod文件。唯一需要此标志的时间是，如果没有指定其他
// 标志，如“go work edit-fmt”中所述。
// 
// -use=path和-dropuse=path标志
// go中添加和删除一个use指令。工作文件的一组模块目录。
// 
// replace=old[@v]=new[@v]标志添加给定
// 模块路径和版本对。如果@v在old@v省略后，添加了一个左侧没有版本的
// 替换，将
// 应用于旧模块路径的所有版本。如果@v在new@v省略，
// 新路径应该是本地模块根目录，而不是模块
// 路径。请注意，-replace会覆盖旧[@v]的任何冗余替换，
// 因此省略@v将删除特定版本的现有替换。
// 
// dropreplace=old[@v]标志删除给定
// 模块路径和版本对的替换。如果省略了@v，则删除左侧不带
// 的替换版本。
// 
// 可以重复使用-use、-dropuse、-replace和-dropreplace，
// 编辑标志，并按给定顺序应用更改。
// 
// go=version标志设置预期的go语言版本。
// 
// print标志将打印最终的go。以文本格式工作，而不是
// 将其写回原处。摩登派青年
// 
// json标志将打印最终的go。JSON格式的工作文件，而不是
// 将其写回原处。摩登派青年JSON输出对应于这些Go类型：
// 
// type GoWork struct{
// Go string 
// Use[]Use 
// Replace[]Replace 
// }
// 
// type Use STRUCE{
// 磁盘路径字符串
// 模块路径字符串
// /}
// 
// 类型替换结构{
// 旧模块
// 新模块
// /}
// 类型模块结构{
// 路径字符串
// 版本字符串
// }
// 
// 参见https:
// 了解更多信息。
// 
// 
// 初始化工作区文件
// 
// 用法：
// 
// go work init[moddirs]
// 
// 初始化并写入一个新的go。
// 当前目录中的工作文件，实际上是在当前
// 目录中创建一个新的工作区。
// 
// go work init可选地接受指向工作区模块的路径作为
// 参数。如果省略参数，将创建一个没有
// 模块的空工作区。
// 
// 每个参数路径都被添加到go中的use指令中。工作文件。
// 当前go版本也将列在go中。工作文件。
// 
// 参见https:
// 了解更多信息。
// 
// 
// 将工作区构建列表同步到模块
// 
// 用法：
// 
// 开始工作同步
// 
// 将工作区的构建列表同步回
// 工作区的模块
// /（可传递）依赖模块的版本集。go 
// 工作同步使用最小版本选择
// 算法生成生成列表，然后将这些版本同步回工作区中指定的每个模块
// 中（使用指令）。
// 
// 同步是通过依次将工作区模块中指定的每个依赖项
// 模块升级到生成列表中的版本来完成的，前提是依赖项模块的版本与生成
// 列表的版本不相同。注意，最小版本选择保证每个模块的
// 构建列表的版本始终与每个工作区模块中的
// 相同或更高。
// 
// 参见https:
// 了解更多信息。
// 
// 
// 将模块添加到工作区文件
// 
// 用法：
// 
// go work use[-r]moddirs 
// 
// Use提供了一个命令行界面，用于向go添加
// 目录（可选递归）。工作文件。
// 
// go中将添加一个use指令。每个参数的工作文件
// 目录列在命令行go上。工作文件，如果存在于磁盘上，
// 或从go中删除。工作文件（如果磁盘上不存在）。
// 
// r标志递归搜索参数
// 目录中的模块，use命令的操作方式就好像每个目录
// 都被指定为参数：即，将为存在的
// 目录添加use指令，并为不存在的目录删除。
// 
// 参见https:
// 了解更多信息。
// 
// 
// 编译并运行Go程序
// 
// 用法：
// 
// Go run[build flags][execxprog]包[arguments…]
// 
// Run编译并运行命名的主Go包。
// 通常，包被指定为。go源文件来自单个
// 目录，但也可能是导入路径、文件系统路径或模式
// 与单个已知包匹配，如“go run”或者“运行my/cmd”。
// 
// 如果package参数有版本后缀（如@latest或@v1.0.0），则
// “go run”以模块感知模式构建程序，忽略go。mod file in 
// 当前目录或任何父目录（如果有）。这对于在不影响主模块依赖关系的情况下运行程序非常有用。
// 
// 如果package参数没有版本后缀，“go run”可以在
// 模块感知模式或GOPATH模式下运行，具体取决于GO111模块环境
// 变量和go的存在。mod文件。有关详细信息，请参阅“go帮助模块”。
// 如果启用了模块感知模式，“go run”将在主
// 模块的上下文中运行。
// 
// 默认情况下，“go run”直接运行编译后的二进制文件：“a.out arguments…”。
// 如果给出了-exec标志，“go run”将使用xprog调用二进制文件：
// /'xprog a.out arguments…'。
// 如果未给出-exec标志，GOOS或GOARCH与系统
// 默认值不同，在当前搜索路径上可以找到名为go_$GOOS_$GOARCH_exec的程序
// go run使用该程序调用二进制文件，例如“go_js_wasm_Execa.out参数…”。当模拟器或其他执行方法可用时，允许执行交叉编译的程序。
// 
// Run的退出状态不是已编译二进制文件的退出状态。
// 
// 有关生成标志的更多信息，请参阅“go help build”。
// 有关指定程序包的更多信息，请参阅“go help packages”。
// 
// 另请参见：go build。
// 
// 
// 测试包
// 
// 用法：
// 
// go Test[构建/测试标志][包][构建/测试标志和测试二进制标志]
// 
// “go Test”自动测试由导入路径命名的包。
// 它以以下格式打印测试结果摘要：
// 
// ok archive/tar 0.011s 
// FAIL archive/zip 0.022s 
// ok compress/gzip 0.033s 
// 。。。
// 
// 然后是每个失败包的详细输出。
// 
// “Go test”重新编译每个包以及名称与
// 文件模式“*_test.Go”匹配的任何文件。
// 这些附加文件可以包含测试函数、基准函数、模糊
// 测试和示例函数。有关更多信息，请参阅“go help testfunc”。
// 每个列出的包都会导致执行一个单独的测试二进制文件。
// 名称以“u”（包括“_test.go”）或“.”开头的文件都被忽略了。
// 
// 声明后缀为“_Test”的包的测试文件将被编译为
// 单独的包，然后与主测试二进制文件链接并运行。
// 
// go工具将忽略名为“testdata”的目录，使其可用
// 来保存测试所需的辅助数据。
// 
// 作为构建测试二进制文件的一部分，go test在包
// 及其测试源文件上运行go vet，以识别重大问题。如果go vet 
// 发现任何问题，go test会报告这些问题，并且不会运行测试
// 二进制文件。
// 仅使用默认go-vet检查的高置信子集。该子集是：“原子”、“布尔”、“构建标记”、“错误标记”、“
// /'ifaceassert”、“nilfunc”、“printf”和“stringintconv”。您可以通过“go doc cmd/vet”查看
// 这些和其他vet测试的文档。
// 要禁用go vet的运行，请使用-vet=off标志。要运行所有
// 检查，请使用-vet=all标志。
// 
// 所有测试输出和摘要行都打印到go命令的
// 标准输出，即使测试将它们打印到自己的标准
// 错误。（go命令的标准错误保留用于打印
// 生成测试的错误。）
// 
// Go测试以两种不同的模式运行：
// 
// 第一种模式称为本地目录模式，当Go测试在没有包参数的情况下调用
// 时（例如，“Go test”或“Go 
// test-v”）。在此模式下，go test编译当前目录中找到的包源代码和
// 测试，然后运行生成的
// 测试二进制文件。在这种模式下，缓存（将在下面讨论）被禁用。
// 包测试完成后，go test打印一个摘要行
// 显示测试状态（“ok”或“FAIL”）、包名和经过的
// 时间。
// 
// 第二种称为包列表模式，在使用显式包参数调用go test时发生（例如“go test math”、“go 
// test./”，甚至“go test”）。在此模式下，go test编译
// 并测试命令行上列出的每个包。如果
// 包测试通过，go测试只打印最后的“ok”摘要
// 行。如果包测试失败，go test将打印完整的测试输出。
// 如果使用-bench或-v标志调用，go test会打印完整的
// 输出，即使通过了包测试，也会显示
// 请求的基准测试结果或详细日志记录。所有列出的包的测试完成后，其输出为
// 打印，如果任何包测试
// 失败，go test将打印最终的“失败”状态。
// 
// 仅在软件包列表模式下，go test缓存成功的软件包测试
// 结果，以避免不必要的重复运行测试。当
// 测试结果可以从缓存中恢复时，go test将重新显示之前的输出，而不是再次运行测试二进制
// 。发生这种情况时，go test打印“（缓存）”以代替摘要行中的
// 已用时间。
// 
// 缓存中匹配的规则是，运行涉及相同的
// 测试二进制文件，命令行上的标志完全来自
// 限制的“可缓存”测试标志集，定义为-benchtime、-cpu、
// /-list、-parallel、-run、-short、-timeout、-failfast、，和-v.
// 如果运行go测试的任何测试或非测试标志在此集合之外，则
// 结果不会被缓存。要禁用测试缓存，请使用除可缓存标志之外的任何测试标志
// 或参数。明确禁用
// 测试缓存的惯用方法是使用-count=1。测试在
// 包的源根目录（通常为$GOPATH）中打开的文件，或参考环境
// 变量的文件只与文件和环境
// 变量不变的未来运行相匹配。缓存的测试结果被视为立即执行
// 因此，无论-timeout设置如何，成功的包测试结果都将被缓存并重新使用。
// 
// 除了构建标志外，“go test”本身处理的标志是：
// 
// /-args 
// 将命令行的剩余部分（在-args之后的所有内容）
// 传递给测试二进制文件，不解释也不改变。
// 由于此标志占用命令行的其余部分，
// 包列表（如果存在）必须出现在此标志之前。
// 
// -c 
// 将测试二进制文件编译为pkg。测试但不运行
// /（其中pkg是包导入路径的最后一个元素）。
// 可以使用-o标志更改文件名。
// 
// exec xprog 
// 使用xprog运行测试二进制文件。该行为与“快跑”中的
// 相同。有关详细信息，请参阅“go help run”。
// 
// -i 
// 安装测试依赖的软件包。
// 不要运行测试。
// 不推荐使用-i标志。编译后的包会自动缓存。
// 
// -json 
// 将测试输出转换为适合自动处理的json。
// 有关编码的详细信息，请参阅“go doc test2json”。
// 
// /-o文件
// 将测试二进制文件编译到指定文件。
// 测试仍在运行（除非指定了-c或-i）。
// 
// 测试二进制文件也接受控制测试执行的标志；这些
// 标志也可以通过“go test”访问。有关详细信息，请参阅“go help testflag”。
// 
// 有关生成标志的更多信息，请参阅“go help build”。
// 有关指定包的更多信息，请参阅“go help packages”。
// 
// 另请参见：开始建造，开始检查。
// 
// 
// 运行指定的围棋工具
// 
// 用法：
// 
// 围棋工具[-n]命令[args…]wen jian defg
// 不带任何参数，它会打印已知工具的列表。
// 
// n标志使工具打印将执行但不执行的命令。
// 
// 有关每个工具命令的更多信息，请参阅“go doc cmd/<command>”。
// 
// 
// 打印Go版本
// 
// 用法：
// 
// Go version[-m][v][file…]
// 
// 版本打印Go可执行文件的构建信息。
// 
// Go版本报告用于构建每个命名
// 可执行文件的Go版本。
// 
// 如果命令行上没有命名文件，go版本将打印自己的
// 版本信息。
// 
// 如果一个目录被命名，go version将递归地遍历该目录，
// 查找可识别的go二进制文件并报告其版本。默认情况下，go版本不会报告在目录扫描期间发现的无法识别的文件。v标志会导致它报告无法识别的文件。
// 
// 如果可用，-m标志会使go版本打印每个可执行文件的嵌入式
// 模块版本信息。在输出中，模块
// 信息由版本行后面的多行组成，每个
// 由前导制表符缩进。
// 
// 另请参见：go doc runtime/debug。BuildInfo。
// 
// 
// 报告包中可能的错误
// 
// 用法：
// 
// go vet[-n][x][vettool prog][build vet flags][packages 
// 
// vet在导入路径指定的包上运行go vet命令。
// 
// 有关vet及其标志的更多信息，请参阅“go doc cmd/vet”。
// 有关指定包的更多信息，请参阅“go help packages”。
// 有关跳棋及其标志的列表，请参阅“go tool vet help”。
// 有关特定检查器（如“printf”）的详细信息，请参阅“go tool vet help printf”。
// 
// n标志打印将要执行的命令。
// 执行命令时，-x标志会打印命令。
// 
// 使用-vettool=prog标志选择另一个分析工具，并进行替代
// 或其他检查。
// 例如，可以使用以下命令构建和运行“阴影”分析器：
// 
// 去安装golang。org/x/tools/go/analysis/passs/shadow/cmd/shadow 
// go-vet-vettool=$（哪个shadow）
// 
// go-vet支持的构建标志是那些控制包解析
// 和执行的标志，例如-n、-x、-v、-tags和-toolexec。
// 有关这些标志的更多信息，请参阅“go help build”。
// 
// 另请参见：go fmt，go fix。
// 
// 
// Build constraints 
// 
// Build constraint，也称为Build tag，是以
// 
// go Build 
// 
// 开头的行注释，列出了文件应包含在包中的条件。
// 约束可能出现在任何类型的源文件中（不仅仅是Go），但
// 约束必须出现在文件顶部附近，前面只有空行和其他行注释。这些规则意味着在Go 
// 文件中，必须在package子句之前出现一个build约束。
// 
// 为了区分构建约束和包文档，
// 构建约束后面应该有一个空行。
// 
// 构建约束作为包含选项
// 的表达式进行计算，该表达式由| |和&&&&！运算符和括号。运算符的
// 含义与Go中的相同。
// 
// 例如，当满足“linux”和“386”约束时，以下生成约束将文件约束为
// 生成，或者当
// “darwin”满意而“cgo”不满意时：
// 
// /go:build（linux&&386）| |（darwin&&cgo）
// 
// 一个文件有多个
// 
// 在特定构建过程中，满足以下条件：
// 
// -目标操作系统，由运行时拼写。GOOS，设置为
// GOOS环境变量。
// /-运行时拼写的目标体系结构。GOARCH，使用
// GOARCH环境变量设置。
// /-如果支持cgo命令，则使用的编译器可以是“gc”或“gccgo”
// /-“cgo”（请参见
// /'go help environment'中启用的cgo_）。
// /-当前版本中每个Go主要版本的术语：
// /“go1.1”从Go版本1.1开始，“go1.12”从Go 1.12开始，依此类推。
// /-由-tags标志给出的任何附加标记（请参阅“go help build”）。
// 
// 对于测试版或次要版本，没有单独的构建标签。
// 
// 如果文件名去掉扩展名和可能的_test后缀，
// 匹配以下任何模式：
// /*\u GOOS 
// /*\u GOARCH 
// /*\u GOOS GOARCH 
// （示例：source_windows_amd64.go）其中GOOS和GOARCH分别代表
// /任何已知的操作系统和架构值，然后
// 文件被认为具有隐式构建约束，需要
// 这些术语（除了文件中的任何显式约束）。
// 
// 除了android标记和文件之外，使用GOOS=android将生成标记和文件与GOOS=linux 
// 匹配。
// 
// 除了illumos标记和文件之外，使用GOOS=illumos与GOOS=solaris 
// 的构建标记和文件相匹配。
// 
// 除了ios标记和文件之外，使用GOOS=ios匹配GOOS=darwin的构建标记和文件。
// 
// 避免在构建时考虑使用文件：
// 
// /go:build ignore 
// 
// （任何其他不满意的词也可以使用，但“ignore”是常规用法。）
// 
// 仅在使用cgo且仅在Linux和OS X上构建文件：
// 
// /go:build cgo&（Linux |达尔文）
// 
// 此类文件通常与实现
// 其他系统默认功能的另一个文件配对，在这种情况下，
// 带有约束：
// 
// /go:build！（cgo&（linux | | darwin））
// 
// 在windows上命名文件。go将使其仅在
// 构建Windows软件包时包含；同样，数学386。只有在为32位x86构建软件包时，才会包含
// 。
// 
// Go版本1.16和更早版本对构建约束使用了不同的语法，
// 带有“
// 约束。
// 
// 
// 构建模式
// 
// go Build和go install命令使用-buildmode参数
// 指示要构建哪种类型的对象文件。当前支持的值
// 是：
// 
// /-buildmode=archive 
// 将列出的非主程序包编译到。a档案。名为
// main的包被忽略。
// 
// /-buildmode=c-archive 
// 将列出的主程序包及其导入的所有程序包
// 构建到c存档文件中。唯一可调用的符号是那些使用cgo
// 函数。需要
// 只列出一个主程序包。
// 
// /-buildmode=c-shared 
// 将列出的主包及其导入的所有包
// 构建到c共享库中。唯一可调用的符号将是那些使用cgo
// 要求只列出一个主包。
// 
// /-buildmode=默认
// 列出的主程序包内置于可执行文件中，列出的
// 非主程序包内置于可执行文件中。a文件（默认的
// 行为）。
// 
// /-buildmode=shared 
// 将所有列出的非主包合并到一个共享
// 库中，在使用-linkshared 
// 选项构建时将使用该库。名为main的包被忽略。
// 
// /-buildmode=exe 
// 构建列出的主程序包及其导入到
// 可执行文件中的所有内容。未命名为main的包将被忽略。
// 
// /-buildmode=pie 
// 构建列出的主程序包及其导入到
// 定位独立可执行文件（pie）。未命名为
// main的包将被忽略。
// 
// /-buildmode=plugin 
// 将列出的主程序包以及它们导入的所有程序包构建到Go插件中。未命名为main的包将被忽略。
// 
// 在AIX上，当链接使用由
// /-buildmode=C-archive构建的Go归档的C程序时，必须将-Wl，-bnobjreorder传递给C编译器。
// 
// 
// 在Go和C之间调用
// 
// 在Go和C/C++代码之间调用有两种不同的方式。
// 
// 第一个是cgo工具，它是Go发行版的一部分。有关
// 如何使用它的信息，请参阅cgo文档（go doc cmd/cgo）。
// 
// 第二个是SWIG程序，它是
// 语言间接口的通用工具。有关SWIG的信息，请参见
// swig.org/.运行go build时，任何带有。swig 
// 扩展将传递给swig。任何带有。swigcxx扩展
// 将通过-c++选项传递给SWIG。
// 
// 当使用cgo或SWIG时，go build将通过任何测试。CMsS 
// 或。sx文件到C编译器，以及任何。抄送。cpp。CXX文件到C++ ABCDEGG 
// 
// 
// 构建和测试缓存
// 
// go命令缓存构建输出，以便在将来的构建中重用。chuang jian defg
// 设置GOCACHE环境变量将覆盖此默认值，
// 并运行“go env GOCACHE”打印当前缓存目录。
// 
// go命令定期删除最近未使用的缓存数据。运行“go clean-cache”会删除所有缓存的数据。
// 
// 构建缓存正确地考虑了对Go源文件、
// 编译器、编译器选项等的更改：在典型使用中，应该不需要显式清理缓存
// 。但是，构建缓存
// 没有检测到对使用cgo导入的C库的更改。
// 如果您对系统上的C库进行了更改，您
// 将需要显式清理缓存，或者使用-a build标志
// （请参阅“go help build”）强制重新生成依赖于更新的C库的包。
// 
// go命令还缓存成功的包测试结果。
// 有关详细信息，请参阅“go help test”。运行“goclean-testcache”将删除所有缓存的测试结果（但不是缓存的生成结果）。
// 
// go命令还使用“go test-fuzz”，
// 来缓存模糊中使用的值。具体来说，这些值在传递给
// fuzz函数时扩展了代码覆盖范围。这些值不用于常规构建和
// 测试，但它们存储在构建缓存的子目录中。
// 运行“go clean-fuzzcache”将删除所有缓存的模糊值。
// 这可能会暂时降低模糊的效果。
// 
// GODEBUG环境变量可以启用打印调试
// 有关缓存状态的信息：
// 
// GODEBUG=gocacheverify=1使go命令绕过
// 使用任何缓存项，而是重建所有内容并检查
// 结果是否正确匹配现有缓存项。
// 
// GODEBUG=gocachehash=1使go命令打印用于构造缓存查找键的所有内容哈希的输入
// 。
// 输出量很大，但对调试缓存很有用。
// 
// GODEBUG=gocachetest=1使go命令打印其
// 关于是否重用缓存测试结果的决定的详细信息。
// 
// 
// 环境变量
// 
// go命令及其调用的工具请参考环境变量
// 进行配置。如果环境变量未设置，go命令
// 将使用合理的默认设置。要查看
// 变量<NAME>的有效设置，请运行“go env<NAME>”。要更改默认设置，
// 运行'go env-w<NAME>=<VALUE>'。根据操作系统的报告，使用“go env-w”
// 更改的默认值记录在存储在
// 每个用户配置目录中的go环境配置文件中。UserConfigDir。
// 可以通过设置
// 环境变量GOENV来更改配置文件的位置，“go env GOENV”打印
// 有效位置，但“go env-w”不能更改默认位置。
// 有关详细信息，请参阅“go help env”。
// 
// 通用环境变量：
// 
// GO111模块
// 控制go命令是在模块感知模式还是GOPATH模式下运行。
// 可能是“关闭”、“打开”或“自动”。
// 见https:
// GCCGO 
// /go build-compiler=GCCGO运行的GCCGO命令。
// GOARCH 
// 编译代码的体系结构或处理器。
// 例如amd64、386、arm和ppc64。
// GOBIN 
// 安装命令的目录。
// GOCACHE 
// go命令将在其中存储缓存的
// 信息，以便在将来的构建中重用。
// GOMODCACHE 
// go命令将存储下载模块的目录。
// GODEBUG 
// 启用各种调试设施。有关详细信息，请参阅“go doc runtime”
// 。
// GOENV 
// Go环境配置文件的位置。
// 无法使用“go env-w”设置。
// 在环境中设置GOENV=off将禁用
// 默认配置文件。
// GOFLAGS 
// 当
// to go命令的-flag=值设置的空格分隔列表。每个条目都必须是独立的标志。
// 当前命令已知给定标志时，默认情况下应用
// 因为条目是空格分隔的，所以标志值必须不包含空格。命令行
// 上列出的标志在此列表之后应用，因此会覆盖它。
// GOINSECURE 
// glob模式的逗号分隔列表（在Go's path.Match的语法中）
// 模块路径前缀的列表，这些前缀应该始终以不安全的方式获取。仅适用于直接获取的依赖项。
// GOINSECURE不禁用校验和数据库验证。GOPRIVATE或
// GONOSUMDB可用于实现这一目标。
// GOOS 
// 编译代码的操作系统。
// 例如linux、darwin、windows和netbsd。
// GOPATH 
// 有关更多详细信息，请参阅：“go help GOPATH”。
// GOPROXY 
// Go模块代理的URL。看见https:
// 和https:
// GOPRIVATE、GONOPROXY、GONOSUMDB 
// glob模式的逗号分隔列表（采用Go的path.Match语法）
// 模块路径前缀，这些前缀应始终直接获取
// 或不应与校验和数据库进行比较。
// 参见https:
// GOSUMDB 
// 要使用的校验和数据库的名称，以及可选的公钥和
// URL。看见https:
// GOTMPDIR 
// go命令将在其中写入
// 临时源文件、包和二进制文件的目录。
// GOVCS 
// 列出了可能与匹配服务器一起使用的版本控制命令。
// 参见“帮助风投”。
// GOWORK 
// 在模块感知模式下，使用给定的go。将工作文件作为工作区文件。
// 默认情况下，或者当GOWORK为“自动”时，go命令将搜索名为go的
// 文件。在当前目录中工作，然后包含目录
// 直到找到一个。如果一个有效的开始。找到工作文件后，指定的模块
// 将作为主要模块一起使用。如果GOWORK 
// 处于“关闭”状态，或是开始。在“自动”模式下找不到工作文件，工作区
// 模式已禁用。
// 
// 与cgo一起使用的环境变量：
// 
// AR 
// 在使用gccgo编译器编译时用于操作库存档的命令。
// 默认为'ar'。
// CC 
// 用于编译C代码的命令。
// CGO_启用
// 是否支持CGO命令。0或1。
// CGOcflags
// 在编译
// C代码时，CGO将传递给编译器的标志。
// CGO_CFLAGS_ALLOW 
// 一个正则表达式，指定允许
// 出现在#CGO CFLAGS源代码指令中的附加标志。
// 不适用于CGO_CFLAGS环境变量。
// CGO_CFLAGS_DISALLOW 
// 一个正则表达式，指定必须禁止的标志
// 出现在#CGO CFLAGS源代码指令中。
// 不适用于CGO_CFLAGS环境变量。
// CGO_CPPFLAGS，CGO_CPPFLAGS_ALLOW，CGO_CPPFLAGS_DISALLOW，
// 。AbDFEG
// CGO_FFLAGS，CGO_FFLAGS_允许，CGO_FFLAGS_不允许
// 类似于CGO_CFLAGS，CGO_CFLAGS_允许，CGO_CFLAGS_不允许，
// 但是对于Fortran编译器。
// CGO_LDFLAGS，CGO_LDFLAGS_ALLOW，CGO_LDFLAGS_DISALLOW 
// 像CGO_CFLAGS一样，CGO_CFLAGS_允许，CGO_CFLAGS_不允许，
// 但对于链接器。ABCFDG 
// FC 
// 用于编译Fortran代码的命令。
// PKG_配置
// PKG配置工具的路径。
// 
// 特定于体系结构的环境变量：
// 
// GOARM 
// For GOARCH=arm，要编译的arm体系结构。
// 有效值为5,6,7。
// GO386 
// 对于GOARCH=386，如何实现浮点指令。
// 有效值为sse2（默认值），softfloat。
// GOAMD64 
// For GOARCH=amd64，要编译的微体系结构级别。
// 有效值为v1（默认）、v2、v3、v4。
// 参见https:
// GOMIPS 
// 对于GOARCH=mips{，le}，是否使用浮点指令。
// 有效值为硬浮点（默认）、软浮点。
// GOMIPS64 
// 对于GOARCH=mips64{，le}，是否使用浮点指令。
// 有效值为硬浮点（默认）、软浮点。
// GOPPC64 
// 对于GOARCH=ppc64{，le}，目标ISA（指令集体系结构）。
// 有效值为power8（默认值）、power9。
// GOWASM 
// GOARCH=wasm，以逗号分隔的实验性WebAssembly特性列表。
// 有效值为satconv，signext。
// 
// 特殊用途环境变量：
// 
// GCCGOTOLDIR 
// 如果设置，在哪里可以找到gccgo工具，例如cgo。
// 默认值基于gccgo的配置方式。
// GOEXPERIMENT 
// 要启用或禁用的工具链实验的逗号分隔列表。
// 可用的实验列表可能会随时间任意变化。
// 参见src/internal/goexperiment/flags。选择当前有效的值。
// 警告：此变量用于Go工具链本身的开发和测试
// 。不支持超出该用途的使用。
// GOROOT_FINAL 
// 安装的Go树的根，当它是
// 安装在构建位置以外的位置时。
// 堆栈跟踪中的文件名从GOROOT重写为
// GOROOT_FINAL。
// GO_EXTLINK_ENABLED 
// 链接器是否应使用外部链接模式
// 在使用cgo的代码时使用-linkmode=auto。
// 设置为0可禁用外部链接模式，设置为1可启用外部链接模式。
// GIT_ALLOW_协议
// 由GIT定义。以冒号分隔的方案列表，允许
// 与git fetch/clone一起使用。如果设置，任何未明确提及的方案将被“go-get”视为不安全。
// 因为变量是由Git定义的，所以不能使用'go env-w'设置默认值。wen dang
// GOGCCFLAGS 
// 提供给CC命令的参数的空格分隔列表。
// GOHOSTARCH 
// /Go工具链二进制文件的体系结构（GOARCH）。
// GOHOSTOS 
// Go工具链二进制文件的操作系统（GOOS）。
// GOMOD 
// 通往前进的绝对道路。主模块的mod。
// 如果启用了模块感知模式，但没有go。mod，GOMOD将是
// os。DevNull（类Unix系统上为“/dev/null”，Windows系统上为“NUL”）。
// 如果模块感知模式被禁用，GOMOD将是空字符串。
// GOTOOLDIR 
// go工具（编译、封面、文档等）所在的目录已安装。
// 政府版本
// 运行时报告的已安装Go树的版本。版本
// 
// 
// 文件类型
// 
// go命令检查一组受限文件的内容
// 在每个目录中。它根据文件名的扩展名
// 标识要检查的文件。这些扩展是：
// 
// 。转到
// 转到源文件。
// /。Ch 
// C源文件。
// 如果软件包使用cgo或SWIG，则将使用
// OS本机编译器（通常为gcc）进行编译；否则将触发一个错误。
// /。抄送。cpp。cxx。啊。水电站。HXX ABCFDG 
// 。
// /。m 
// Objective-C源文件。仅适用于cgo，并且总是
// 使用操作系统本机编译器编译。
// /。sssx 
// 汇编程序源文件。
// 如果软件包使用cgo或SWIG，这些将与
// 操作系统本机汇编程序（通常为gcc（sic））组装；否则
// 将使用Go汇编程序进行组装。
// /。大口喝。swigcxx 
// SWIG定义文件。
// /。syso 
// 系统对象文件。
// 
// 这些类型的文件除外。syso可能包含build 
// 约束，但go命令在文件中不是空行或
// 约束。有关
// 行注释的第一项停止扫描build constraints 
// 更多详细信息，请参阅go/build软件包文档。
// 
// 
// go。mod file 
// 
// 模块版本由源文件树定义，带有go。mod 
// 根目录中的文件。当go命令运行时，它会在当前的
// 目录中查找go，然后在后续的父目录中查找go。mod 
// 标记主（当前）模块的根。快走。mod文件格式详见
// golang.org/ref/mod#go-mod文件。
// 
// 创建新围棋。mod file，使用'go mod init'。有关详细信息，请参见
// golang.org/ref/mod#go-mod init。
// 
// 要添加缺失的模块需求或删除不必要的需求，
// 使用“go mod tidy”。有关详细信息，请参阅“go help mod tidy”或
// https:
// 
// 要添加、升级、降级或删除特定的模块需求，请使用
// “go get”。有关详细信息，请参阅“go help module get”或
// https:
// 
// 进行其他更改或解析go。mod as JSON供其他工具使用，
// 使用'go mod edit'。请参阅“go help mod edit”或
// https:
// 
// 
// GOPATH环境变量
// 
// Go path用于解析导入语句。
// 它由go/build包实现并记录在其中。
// 
// GOPATH环境变量列出了查找Go代码的位置。
// 在Unix上，该值是以冒号分隔的字符串。
// 在Windows上，该值是以分号分隔的字符串。
// 在计划9中，值是一个列表。
// 
// 如果环境变量未设置，GOPATH将默认
// 到用户主目录中名为“go”的子目录
// （Unix上为$home/go，%USERPROFILE%\go Windows上为$go），
// 除非该目录包含go分发。
// 运行“go env GOPATH”查看当前的GOPATH。
// 参见https:
// 
// GOPATH中列出的每个目录必须具有指定的结构：
// 
// src目录包含源代码。src 
// 下面的路径决定导入路径或可执行文件名。
// 
// pkg目录包含已安装的包对象。
// 与Go树中一样，每个目标操作系统和
// 体系结构对都有自己的pkg子目录
// （pkg/GOOS_GOARCH）。
// 
// 如果目录是GOPATH中列出的目录，则在DIR/src/foo/bar中包含
// source的包可以作为“foo/bar”和
// 已将其编译后的表单安装到“DIR/pkg/GOOS_GOARCH/foo/bar.a”。
// 
// bin目录保存已编译的命令。
// 每个命令都是根据其源目录命名的，但只有
// 最后一个元素，而不是整个路径。也就是说，源代码在DIR/src/foo/qux中的
// 命令安装在
// DIR/bin/qux中，而不是DIR/bin/foo/qux中。去掉“foo/”前缀
// 以便您可以将DIR/bin添加到路径中，以获取
// 已安装的命令。如果GOBIN环境变量为
// set，则命令将安装到它命名的目录中，而不是DIR/bin的
// 。戈宾一定是一条绝对的道路。
// 
// 下面是一个目录布局示例：
// 
// GOPATH=/home/user/go 
// 
// home/user/go/
// src/
// foo/
// bar/（打包栏中的go code）
// x、 go 
// quux/（主程序包中的go代码）
// y.go 
// bin/
// quux（已安装命令）
// pkg/
// linux_amd64/
// foo/
// 酒吧（已安装的软件包对象）
// 
// Go搜索GOPATH中列出的每个目录以查找源代码，
// 但新软件包总是下载到列表中的第一个目录
// 中。
// 参见https:
// 
// GOPATH和模块
// 
// 使用模块时，GOPATH不再用于解析导入。
// 但是，它仍然用于存储下载的源代码（在GOPATH/pkg/mod中）和编译的命令（在GOPATH/bin中）。
// 
// 内部目录
// 
// 名为“Internal”的目录中或目录下的代码只能通过“Internal”的父目录树中的代码导入。
// 这是上面目录布局的扩展版本：
// 
// home/user/go/
// /src/
// crash/
// bang/（包中的go代码bang）
// b.go 
// /foo/（foo包中的go代码）
// f.go 
// bar/（bar包中的go代码）
// x.go 
// internal/
// baz/（baz包中的go code
// /quux/（主程序包中的go代码）
// y.go 
// 
// 
// z.go中的代码作为“foo/internal/baz”导入，但
// import语句只能出现在源文件子树
// foo根目录下。源文件foo/f.go、foo/bar/x.go和
// foo/qux/y.go都可以导入“foo/internal/baz”，但源文件
// crash/bang/b.go不能。
// 参见https:
// 
// 供应商目录
// 
// Go 1.6支持使用外部依赖项的本地副本
// 以满足这些依赖项的导入，通常称为供应商。
// 
// 名为“vendor”的目录下的代码只能通过“vendor”的父目录树中的代码导入
// 并且只能使用忽略前缀up和
// 包括vendor元素的导入路径。
// 
// 这是上一节的示例，
// 但将“内部”目录重命名为“供应商”
// 并添加了一个新的foo/vendor/crash/bang目录：
// 
// /home/user/go/
// src/
// crash/
// bang
// b.go-
// foo/（包中的go代码）
// f.go-
// bar/（包中的go代码）
// x.go-
// vendor/
// crash/
// bang/（包bang中的go代码）
// b.go 
// baz/（包baz中的go代码）
// z.go 
// y.go 
// 
// 适用于内部的可见性规则相同，但z.go中的代码
// 被导入为“baz”，而不是“foo/vendor/baz”。
// 
// 源代码树阴影中较深的供应商目录中的代码
// 较高目录中的代码。在以foo为根的子树中，“crash/bang”的导入
// 解析为“foo/vendor/crash/bang”，而不是
// 顶级的“crash/bang”。
// 
// 供应商目录中的代码不受导入路径
// 检查的约束（请参阅“go help importpath”）。
// 
// 当“go get”签出或更新git存储库时，它现在也会更新子模块。
// 
// 供应商目录不会影响新存储库的放置
// 第一次通过“go get”签出：这些目录始终是
// 放在主GOPATH中，而不是放在供应商子树中。
// 参见https:
// 
// 
// Legacy GOPATH go get 
// 
// “go get”命令会根据
// go go命令是在模块感知模式还是在Legacy GOPATH模式下运行而改变行为。
// 此帮助文本即使在模块感知模式下也可以作为“go help gopath get”访问，
// 描述了在传统gopath模式下运行的“go get”。
// 
// 用法：go get[-d][f][t][u][v][fix][build flags][packages]
// 
// get下载按导入路径命名的包，以及它们的
// 依赖项。然后安装命名的软件包，比如“go install”。wen dang
// 它指示get不要安装软件包。
// 
// 仅当设置了-u时，-f标志才有效，它强制get-u不验证
// 每个包是否已从源代码管理存储库中签出
// 由其导入路径隐含。如果源代码是原始代码的本地分支
// 这可能很有用。
// 
// 在解析依赖项或生成代码之前，-fix标志指示get在下载的包上运行修复工具。
// 
// t标志指示get也下载构建
// 指定包的测试所需的包。
// 
// u标志指示get使用网络更新命名包
// 及其依赖项。默认情况下，get使用网络检查
// 缺少的包，但不使用它查找现有包的更新。
// 
// v标志启用详细进度和调试输出。
// 
// Get也接受生成标志来控制安装。请参阅“go help build”。chu cdefg
// get将使用第一个条目。有关更多详细信息，请参阅“go help gopath”。
// 
// 签出或更新软件包时，get会查找与本地安装的Go版本匹配的分支或标记
// 。最重要的
// 规则是，如果本地安装运行的是版本“go1”，get 
// 将搜索名为“go1”的分支或标记。如果不存在这样的版本
// 它将检索包的默认分支。
// 
// 当go get签出或更新Git存储库时，
// 它还会更新存储库引用的任何Git子模块。
// 
// Get never签出或更新存储在供应商目录中的代码。
// 
// 有关指定包的更多信息，请参阅“go help packages”。
// 
// 有关“go get”如何查找
// 源代码的更多信息，请参阅“go help importpath”。
// 
// 本文描述了使用GOPATH 
// 管理源代码和依赖项时get的行为。
// 如果改为go命令在模块感知模式下运行，则
// get的标志和效果的详细信息会发生变化，“go help get”也会发生变化。
// 参见“go help module”和“go help module get”。
// 
// 另请参见：开始构建、开始安装、开始清理。
// 
// 
// 模块代理协议
// 
// Go模块代理是任何可以响应GET请求的web服务器，用于获取指定格式的
// URL。这些请求没有查询参数，因此即使是来自固定文件系统（包括文件：
// 也可以作为模块代理。有关GOPROXY协议的详细信息，请参见https:
// 
// 
// 导入路径语法
// 
// 导入路径（请参阅“go help packages”）表示存储在本地
// 文件系统中的包。通常，导入路径表示一个标准包（如“unicode/utf8”之类的
// 或在其中一个工作空间中找到的包（有关更多
// 详细信息，请参阅：“go help gopath”）。
// 
// 相对导入路径
// 
// 以开头的导入路径。/或者被称为相对路径。
// 工具链以两种方式支持相对导入路径作为快捷方式。
// 
// 首先，相对路径可以在命令行中用作简写。
// 如果您在包含作为
// /“unicode”导入的代码的目录中工作，并且希望运行“unicode/utf8”的测试，则可以键入
// /“go test./utf8”，而无需指定完整路径。
// 同样，在相反的情况下，“进行测试……”将从
// “unicode/utf8”目录测试“unicode”。也允许使用相对模式，例如
// /“go test./…”测试所有子目录。有关模式语法的详细信息，请参见“go help packages”。
// 
// 其次，如果您正在编译一个不在工作空间中的Go程序，
// 您可以在该程序的导入语句中使用相对路径
// 来引用附近也不在工作空间中的代码。这使得在通常的工作空间之外试验小型多包程序变得很容易，但这些程序不能用“go install”（没有安装它们的工作空间）来安装，所以每次构建时都会从头开始重建。
// 为避免歧义，Go程序不能在工作空间内使用相对导入路径
// 。
// 
// 远程导入路径
// 
// 某些导入路径也
// 描述如何使用
// 版本控制系统获取包的源代码。
// 
// 一些常见的代码托管网站有特殊的语法：
// 
// Bitbucket（Git，Mercurial）
// 
// 导入“Bitbucket.org/user/project”
// 导入“Bitbucket.org/user/project/sub/directory”
// 
// 导入“github.com/user/project”
// 导入“github.com/user/project/sub/directory”
// 
// Launchpad（Bazaar）
// 
// 导入“Launchpad.net/project”
// 导入“Launchpad.net/project/series”
// 
// 导入“launchpad.net/~user/project/branch”
// 导入“launchpad.net/~user/project/branch/sub/directory”
// 
// IBM DevOps Services（Git）
// /
// 导入“hub.jazz.net/Git/user/project”
// 
// 对于托管在其他服务器上的代码，导入路径可以是具有版本控制类型的限定
// 或者go工具可以通过https/http动态获取
// 导入路径，并从HTML中的<meta>标记中发现代码所在的位置
// 。
// 
// 要声明代码位置，请使用格式为
// 
// repository的导入路径。vcs/path 
// 
// 指定给定的存储库，带或不带。vcs后缀
// 使用命名的版本控制系统，然后是
// 存储库中的路径。支持的版本控制系统有：
// 
// Bazaar。bzr 
// 化石。化石
// Git。git 
// Mercurial。hg 
// 颠覆。svn 
// 
// 例如，
// 
// 导入“example.org/user/foo.hg”
// 
// 表示位于
// 示例的Mercurial存储库的根目录。org/user/foo或foo。hg和
// 
// import“example.org/repo.git/foo/bar”
// 
// 表示位于
// example的git存储库的foo/bar目录。组织/回购或回购。吉特。
// 
// 当版本控制系统支持多个协议时，
// 在下载时依次尝试每个协议。例如，Git 
// 下载尝试https:
// Git_ALLOW_协议环境变量（有关更多详细信息，请参阅：
// “go help environment”）。
// 
// 如果导入路径不是已知的代码托管站点，并且缺少
// 版本控制限定符，go工具将尝试通过https/http获取导入
// 并在文档的HTML 
// /<head>中查找<meta>标记。
// 
// 元标记的形式为：
// 
// <meta name=“go import”content=“import prefix vcs repo root”>
// 
// 导入前缀是对应于存储库
// root的导入路径。它必须是一个前缀，或者与
// 获取的带有“go get”的包完全匹配。如果不完全匹配，则在前缀处发出另一个http 
// 请求以验证<meta>标记是否匹配。
// 
// 元标记应尽可能早地出现在文件中。
// 尤其是，它应该出现在任何原始JavaScript或CSS之前，以避免混淆go命令的受限解析器。CDEFG
// 
// repo root是版本控制系统的根
// 包含方案而不包含。风投资格赛。
// 
// 例如，
// 
// 导入“example.org/pkg/foo”
// 
// 将导致以下请求：
// 
// https:
// http:
// 
// 如果该页面包含元标记
// 
// <meta name=“go import”content=“example.org githttps:
// 
// go工具将验证https:
// 相同的元标记，然后是git克隆https:
// GOPATH/src/example。组织。
// 
// 使用GOPATH时，下载的软件包会写入GOPATH环境变量中列出的第一个目录
// 中。
// /（请参阅“go help gopath get”和“go help gopath”。）
// 
// 使用模块时，下载的软件包存储在模块缓存中。
// 参见https:
// 
// 在使用模块时，go import meta标记的另一个变体是
// 可以识别，并且比那些列出的版本控制系统更受欢迎。
// 该变体在内容值中使用“mod”作为vcs，如：
// 
// <meta name=“go import”content=“example.org modhttps:
// 
// 此标记表示从URL上可用的模块代理获取路径以example.org 
// 开头的模块https:
// 参见https:
// 代理协议的详细信息，请参阅协议。
// 
// 导入路径检查
// 
// 当上述自定义导入路径功能重定向到
// 已知代码托管站点时，生成的每个包都有两个可能的
// 导入路径，使用自定义域或已知托管站点。
// 
// 如果一个package语句紧接着
// 后面（在下一个换行之前）是以下两种形式之一的注释，则称其为“导入注释”：
// 
// package math
// package math
// 的软件包，除非该导入路径引用该软件包。这样，导入注释
// 让包作者确保使用自定义导入路径，而不是
// 到基础代码托管站点的直接路径。
// 
// 在供应商树中找到的代码禁用导入路径检查。
// 这样就可以将代码复制到供应商树中的备用位置
// 而无需更新导入注释。
// 
// 在使用模块时，导入路径检查也被禁用。
// 导入路径注释已被go淘汰。mod file的module语句。
// 参见https:
// 
// 
// 模块、模块版本和更多
// 
// 模块是如何管理依赖关系的。
// 
// 模块是一起发布、版本控制和分发的包的集合。模块可以直接从版本控制
// 存储库或模块代理服务器下载。
// 
// 有关模块的系列教程，请参阅
// https:
// 
// 有关模块的详细参考，请参阅https:
// 
// 默认情况下，go命令可以从https:
// 它可以使用
// sum.golang.org.这两项服务都由谷歌的Go团队运营。
// 有关这些服务的隐私政策，请访问
// https:
// 。
// 
// go命令的下载行为可以使用GOPROXY、GOSUMDB、
// GOPRIVATE和其他环境变量进行配置。请参阅“go help environment”
// 和https:
// 
// 
// 使用go进行模块身份验证。当go命令下载模块zip文件或go时，sum 
// 
// 。将mod文件放入
// 模块缓存中，它会计算一个加密哈希，并将其与已知的
// 值进行比较，以验证该文件自首次下载以来未发生更改。已知的
// 散列存储在名为go的模块根目录中的一个文件中。总和根据
// 。
// GOSUMDB、GOPRIVATE和GONOSUMDB的值，也可以从校验和数据库下载哈希值
// 
// 有关详细信息，请参阅https:
// 
// 
// 包列表和模式
// 
// 许多命令应用于一组包：
// 
// go action[packages]
// 
// 通常，[packages]是导入路径的列表。
// 
// 根路径或以
// a开头的导入路径。或元素被解释为文件系统路径，
// 表示该目录中的包。
// 
// 否则，导入路径P表示在
// GOPATH 
// 环境变量中列出的某些目录的目录DIR/src/P（有关更多详细信息，请参阅：“go help GOPATH”）。
// 
// 如果未给出导入路径，则该操作适用于当前目录中的
// 包。
// 
// 对于使用go工具构建的包，有四个不应使用的路径保留名称
// 
// 
// /-“main”表示独立可执行文件中的顶级包。
// 
// -“全部”扩展到所有GOPATH 
// 树中的所有包。例如，“go list all”列出本地
// 系统上的所有软件包。使用模块时，“all”扩展到
// 主模块中的所有包及其依赖项，包括任何这些模块的测试所需的依赖项
// 中的所有包。
// 
// -“std”与所有类似，但仅扩展到标准
// Go库中的包。
// 
// -“cmd”扩展到Go存储库的命令及其内部库。
// 
// 以“cmd/”开头的导入路径仅与Go存储库中的源代码匹配。
// 
// 如果导入路径包含一个或多个“…”则它是一个模式通配符，
// 每个通配符都可以匹配任何字符串，包括空字符串和
// 包含斜杠的字符串。这种模式扩展到GOPATH树中的所有包
// 目录，其名称与
// 模式匹配。
// 
// 为了使普通模式更方便，有两种特殊情况。首先，
// 以便net/。。。匹配net及其子目录中的包，如net/http。
// 第二，任何包含通配符的斜杠分隔模式元素都不会参与卖方
// 包路径中“卖方”元素的匹配，因此。
// 子目录中的包不匹配/供应商或/mycode/供应商，但是/供应商/。。。还有/mycode/vendor/。。。做
// 但是，请注意，一个名为vendor的目录本身包含代码
// 不是一个供应商包：cmd/vendor将是一个名为vendor的命令，
// 和模式cmd/。。。与之匹配。
// 见戈朗。org/s/go15vendor了解更多关于vendoring的信息。
// 
// 导入路径还可以命名要从远程存储库下载的包。有关详细信息，请运行“go help importpath”。
// 
// 程序中的每个包都必须具有唯一的导入路径。
// 按照惯例，这是通过在每条路径的开头添加一个属于您的唯一前缀来安排的。例如，谷歌内部使用的路径
// 都以“Google”开头，而表示远程存储库的路径
// 以代码路径
// 开头，例如“github”。com/user/repo。
// 
// 程序中的包不需要有唯一的包名，
// 但有两个具有特殊含义的保留包名。
// 名称main表示命令，而不是库。
// 命令内置于二进制文件中，无法导入。
// 名称documentation表示目录中非Go程序的文档。go命令会忽略包文档
// 中的文件。
// 
// 作为特例，如果包列表是。go files from a 
// single directory，该命令应用于一个合成的
// 包，该包完全由这些文件组成，忽略这些文件中的任何构建约束
// 并忽略该目录中的任何其他文件。
// 
// 以“.”开头的目录和文件名go工具会忽略“u”
// 以及名为“testdata”的目录。
// 
// 
// 下载非公共代码的配置
// 
// go命令默认为从公共go模块
// 代理镜像下载模块。戈朗。组织。默认情况下，它还会根据sum上的公共Go校验和数据库验证下载的模块
// 无论源代码是什么。戈朗。组织。
// 这些默认值适用于公开的源代码。
// 
// GOPRIVATE环境变量控制go命令
// 认为哪些模块是私有的（不公开），因此不应使用
// 代理或校验和数据库。变量是以逗号分隔的模块路径前缀
// glob模式列表（语法为Go's path.Match）。例如，
// 
// GOPRIVATE=*。公司就是一个例子。com，rsc。io/private 
// 
// 导致go命令将路径前缀为
// 与任一模式（包括git）匹配的任何模块视为专用模块。公司就是一个例子。com/xyzy，rsc。io/private、
// 和rsc。io/private/quux。
// 
// 为了对模块下载和验证进行细粒度控制，GONOPROXY 
// 和GONOSUMDB环境变量分别接受相同类型的全局列表
// 并覆盖GOPRIVATE，以决定是否使用代理
// 和校验和数据库。
// 
// 例如，如果一家公司运行一个为私有模块提供服务的模块代理，
// 用户将使用以下命令配置go:
// 
// GOPRIVATE=*。公司就是一个例子。com 
// GOPROXY=proxy。实例com 
// GONOPROXY=none 
// 
// GOPRIVATE变量还用于定义GOVCS变量的“public”和“private”
// 模式；请参阅“帮助风投”。对于这种用法，
// GOPRIVATE即使在GOPATH模式下也适用。在这种情况下，它将匹配导入路径
// 而不是模块路径。
// 
// 可以使用'go env-w'命令（请参阅'go help env'）来设置这些变量
// 以便将来调用go命令。
// 
// 有关更多详细信息，请参阅https:
// 
// 
// 测试标志
// 
// go test命令接受应用于“go test”本身的标志
// 以及应用于结果测试二进制文件的标志。
// 
// 几个标志控制配置文件并编写执行配置文件
// 适用于“go tool pprof”；运行“go tool pprof-h”获取更多
// 信息。--alloc_space、--alloc_objects和--show_bytes 
// PPR的选项控制信息的显示方式。
// 
// 以下标志由'go test'命令识别，
// 控制任何测试的执行：
// 
// /-bench regexp 
// 仅运行与正则表达式匹配的基准测试。zhong zhong
// 要运行所有基准测试，请使用“-bench”或“-bench=”。
// 正则表达式由无括号斜杠（/）
// 字符分割成一个正则表达式序列，每个
// 基准的标识符部分必须与序列中相应的
// 元素（如果有）匹配。匹配
// 的可能父项在b.N=1的情况下运行，以确定子基准。例如，
// 给定-bench=X/Y，运行与X匹配的顶级基准
// b.N=1以查找与Y匹配的任何子基准，这些子基准是
// 然后完全运行。
// 
// benchtime t 
// 运行每个基准测试的足够迭代，以t为时间，指定
// 。持续时间（例如，-benchtime 1h30）。
// 默认值为1秒（1秒）。
// 特殊语法Nx表示运行基准N次
// （例如，-benchtime 100x）。
// 
// /-count n 
// 运行每个测试、基准测试和模糊种子n次（默认值1）。
// 如果设置了-cpu，则为每个GOMAXPROCS值运行n次。
// 示例始终运行一次-count不适用于
// 由-fuzz匹配的模糊测试。
// 
// -覆盖
// 启用覆盖率分析。
// 请注意，由于覆盖率是通过在编译前注释源代码来实现的，因此使用
// 启用覆盖率可能会报告与
// 原始来源。
// 
// -covermode设置、计数、原子
// 为正在测试的包设置覆盖率分析模式。默认值为“set”，除非启用了-race，否则
// 在这种情况下为“原子”。
// 值：
// set:bool:这个语句运行吗？
// count:int:这个语句运行了多少次？
// 原子：int:count，但在多线程测试中是正确的；
// 明显更贵。
// 套-封面。
// 
// coverpkg模式1、模式2、模式3 
// 在每次测试中对符合模式的包进行覆盖率分析。
// 默认情况下，每个测试只分析正在测试的包。
// 有关包模式的描述，请参阅“go help packages”。
// 套-封面。
// 
// /-cpu 1,2,4 
// 指定应执行测试、基准测试或
// 模糊测试的GOMAXPROCS值列表。默认值为GOMAXPROCS的当前值
// -cpu不适用于与-fuzz匹配的fuzz测试。
// 
// failfast 
// 第一次测试失败后，不要开始新的测试。
// 
// /-fuzz regexp 
// 运行与正则表达式匹配的模糊测试。指定时，
// 命令行参数必须与
// 主模块中的一个包完全匹配，而regexp必须与该包中的一个模糊测试完全匹配。在其他模糊测试的测试、基准测试、种子库
// 和示例完成后，将发生模糊化。有关详细信息，请参阅测试包文档中的Fuzzing 
// 部分。
// 
// /-fuzztime t 
// 在模糊化过程中对模糊目标进行足够多的迭代，以获取指定为时间的t，
// 。持续时间（例如，1小时30分）。
// 默认为永远运行。
// 特殊语法Nx表示运行fuzz目标N次
// （例如，-fuzztime 1000x）。
// 
// /-fuzzminimizetime t 
// 在每次最小化过程中对模糊目标运行足够多的迭代
// 尝试按指定的时间取t。持续时间（例如，
// /-fuzzminimizetime 30s）。
// 默认值为60秒。
// 特殊语法Nx表示将fuzz目标运行N次
// （例如，-fuzzminimizetime 100x）。
// 
// -json 
// /用json记录详细的输出和测试结果。这将以机器可读的格式显示
// 与-v标志相同的信息。
// 
// list regexp 
// 列出与常规
// 表达式匹配的测试、基准测试、模糊测试或示例。不会运行任何测试、基准测试、模糊测试或示例。
// 这将只列出顶级测试。不显示任何子测试或子基准测试。
// 
// -parallel n 
// 允许并行执行调用t.parallel的测试函数，以及
// 在运行种子库时模糊调用t.parallel的目标。
// 此标志的值是同时运行
// 的最大测试数。
// 在进行模糊化时，此标志的值是可以同时调用模糊函数的最大
// 子进程数，而不管是否调用T.Parallel。
// 默认情况下，-parallel设置为GOMAXPROCS的值。
// 设置-与高于GOMAXPROCS的值并行可能会由于CPU争用而导致性能降低，尤其是在模糊化时。
// 请注意，-parallel仅适用于单个测试二进制文件。
// 根据-p标志
// （请参阅“go help build”）的设置，“go test”命令也可以并行运行不同软件包的测试。
// 
// -运行regexp 
// 只运行与常规
// 表达。对于测试，正则表达式由无包装的
// 斜杠（/）字符拆分成一个正则表达式序列，测试标识符的每个
// 部分必须与序列中的相应元素匹配（如果有）。请注意，匹配的可能父项也是
// run，因此-run=X/Y匹配并运行并报告所有匹配X的测试的结果
// ，即使那些没有匹配Y的子测试，
// ，因为它必须运行它们来查找这些子测试。
// 
// -短
// 告诉长时间运行的测试缩短运行时间。
// 默认为关闭，但在所有时间都设置。bash，以便安装
// Go树可以运行健全性检查，但不需要花费时间运行
// 详尽的测试。
// 
// -洗牌关闭、打开、N 
// 随机测试和基准测试的执行顺序。
// 默认为关闭。如果-shuffle设置为on，则它将使用系统时钟为随机化器设定
// 种子。如果将-shuffle设置为
// 整数N，则N将用作种子值。在这两种情况下，
// 将报告种子的再现性。
// 
// -超时d 
// 如果测试二进制文件的运行时间超过持续时间d，则会出现死机。
// 如果d为0，则超时被禁用。
// 默认值为10分钟（10米）。
// 
// /-v 
// 详细输出：记录所有运行的测试。即使测试成功，也要打印日志和Logf调用中的所有
// 文本。
// 
// /-vet list 
// 配置“go test”期间对“go vet”的调用
// 使用逗号分隔的vet检查列表。
// 如果列表为空，“go test”运行“go vet”，其中包含一个精心策划的
// 检查列表，这些检查被认为总是值得处理的。
// 如果列表为“off”，则“go test”根本不运行“go vet”。
// 
// 以下标志也可由'go test'识别，并可用于
// 在执行过程中分析测试：
// 
// /-benchmem 
// 打印基准测试的内存分配统计信息。
// 
// -块配置文件块。out 
// 在所有测试完成后，将GOROUTE阻塞配置文件写入指定文件
// 中。
// 像-c一样写入测试二进制文件。
// 
// -blockprofilerate n 
// 控制
// 调用运行时在goroutine blocking profiles中提供的详细信息。SetBlockProfileRate与n.
// 参见“go doc运行时”。“利率”下降。
// 分析器的目标是，平均每个
// n纳秒程序被阻止时，对一个阻止事件进行采样。默认情况下，
// if-test。blockprofile设置时没有此标志，所有阻塞事件
// 都会被记录，相当于-test。blockprofilerate=1。
// 
// -封面简介封面。out 
// 在通过所有测试后，向文件写入覆盖率配置文件。
// 套-封面。
// 。out 
// 退出前，将CPU配置文件写入指定文件。
// 像-c一样写入测试二进制文件。
// 
// -memprofile mem。out 
// 在所有测试通过后，将分配配置文件写入文件。
// 像-c一样写入测试二进制文件。
// 
// memprofilerate n 
// 通过
// 设置运行时，启用更精确（且更昂贵）的内存分配配置文件。记忆速率。请参阅“go doc运行时”。“利率”。
// 要分析所有内存分配，请使用-test。memprofilerate=1。
// 
// -互斥文件互斥。out 
// 在所有测试完成后，将互斥争用配置文件写入指定的文件
// 中。
// 像-c一样写入测试二进制文件。
// 
// MUTEXPROFILEN 
// /样本1 in n包含
// 竞争互斥的Goroutine堆栈跟踪。
// 
// -outputdir目录
// 将分析的输出文件放在指定的目录中，默认情况下，
// 运行“go test”的目录。
// 
// -跟踪追踪。out 
// 退出前，将执行跟踪写入指定的文件。
// 
// 这些标志中的每一个都可以通过可选的“测试”来识别前缀，
// as in-test。v、 但是，当直接调用生成的测试二进制文件（
// /'go test-c'的结果）时，前缀是必需的。
// 
// 在调用测试二进制文件之前，“go test”命令会根据需要在可选包列表之前和之后重写或删除识别标志，
// 
// 
// 
// 
// 
// go test-v-myflag testdata-cpuprofile=prof.out-x 
// 
// 将编译测试二进制文件，然后作为
// 
// pkg运行。测试-测试。v-myflag testdata-test。cpupofile=prof.out 
// 
// （删除-x标志是因为它只适用于go命令的
// 执行，而不适用于测试本身。）wen jian efg
// 
// 当“go test”运行测试二进制文件时，它会在
// 相应包的源代码目录中运行。根据测试的不同，
// 直接调用生成的测试
// 二进制文件时，可能需要执行相同的操作。由于该目录可能位于
// 模块缓存中，该缓存可能是只读的，并通过校验和进行验证，因此除非用户明确请求（例如使用-fuzz标志，
// 中的任何其他目录。
// 将失败写入testdata/fuzz），否则测试不得写入该目录或模块
// 
// 命令行包列表（如果存在）必须出现在go test命令未知的任何
// 标志之前。继续上面的例子，程序包列表必须出现在-myflag之前，但可以出现在-v的任意一侧。
// 
// 当“go test”在程序包列表模式下运行时，“go test”会缓存成功的
// 程序包测试结果，以避免不必要的重复运行测试。要禁用测试缓存，请使用除
// 可缓存标志之外的任何测试标志或参数。显式禁用测试缓存
// 的惯用方法是使用-count=1。
// 
// 要防止测试二进制文件的参数被解释为
// 已知标志或包名，请使用-args（请参阅“go help test”）。
// 将命令行的其余部分传递给测试二进制文件
// 未解释且未更改。例如，命令
// 
// go test-v-args-x-v 
// 
// 将编译测试二进制文件，然后作为
// 
// pkg运行。测试-测试。v-x-v 
// 
// 类似地，
// 
// go test-args math 
// 
// 将编译测试二进制文件，然后作为
// 
// pkg运行。测试数学
// 
// 在第一个示例中，-x和第二个-v被传递到
// 测试二进制文件不变，对go命令本身没有影响。
// 在第二个示例中，参数math传递给测试
// 二进制，而不是解释为包列表。
// 
// 
// 测试函数
// 
// go test命令希望在“*_test.go”文件中找到测试、基准测试和示例函数
// 。
// 
// 测试函数是一个名为TestXxx的函数（其中Xxx不是以
// 小写字母开头），并且应该有签名，
// 
// func TestXxx（t*testing.t）{…}
// 
// 基准函数是一个名为BenchmarkXxx的函数，应该有签名
// 
// func BenchmarkXxx（b*testing.b）{…}
// 
// 模糊测试是一个名为FuzzXxx的测试，应该有签名，
// 
// func FuzzXxx（f*testing.f）{…}
// 
// 示例函数类似于测试函数，但不是使用
// /*测试。T要报告成功或失败，请将输出打印到操作系统。斯特杜特。
// 如果函数中的最后一条注释以“Output:”开头，则将输出
// 与注释进行精确比较（参见下面的示例）。如果最后一条
// 注释以“无序输出”开头，则将输出与
// 注释进行比较，但忽略行的顺序。没有这样的
// 注释的示例已编译但未执行。
// /“Output:”后面没有文本的示例被编译、执行，预计不会产生任何输出。
// 
// Godoc显示ExampleXxx的正文，以演示函数、常量或变量Xxx的用法。带有
// 接收器类型T或*T的方法M的一个示例被命名为ExampleT_M。对于给定的函数、常数或变量，可能有多个示例
// 以尾随的_xxx、
// 区分，其中xxx是一个后缀，而不是以大写字母开头。
// 
// 下面是一个示例的示例：
// 
// func ExamplePrintln（）{
// Println（“此示例的输出”）
// /输出：本例中
// /的输出。
// }
// 
// 这里是另一个忽略输出顺序的例子：
// 
// func ExamplePerm（）{
// for u，value:=范围Perm（4）{
// /fmt.Println（value）
// 
// /1 
// /3 
// /0 
// }
// /
// 当整个测试文件包含单个
// 示例函数、至少一个其他函数、类型、变量或常量
// 声明，且没有测试、基准、，或者模糊测试。
// 
// 有关更多信息，请参阅测试包的文档。
// 
// 
// 使用GOVCS控制版本控制
// 
// go get命令可以运行git 
// 等版本控制命令来下载导入的代码。这个功能对于分散的
// Go包生态系统至关重要，在这个生态系统中，代码可以从任何服务器导入，
// 但如果恶意服务器发现
// 方法导致调用的版本控制命令运行意外代码，这也是一个潜在的安全问题。
// 
// 为了平衡功能性和安全性，默认情况下，“go get”命令
// 将仅使用git和hg从公共服务器下载代码。
// 但它将使用任何已知的版本控制系统（bzr、fossil、git、hg、svn）
// 从专用服务器下载代码，专用服务器定义为托管与GOPRIVATE变量匹配的包
// 的服务器（请参阅“go help private”）。
// 只允许Git和Mercurial的理由是，这两个系统对作为不受信任服务器的客户端运行的问题最为关注。相比之下，
// Bazaar、Fossil和Subversion主要用于受信任的、经过身份验证的环境，没有受到攻击表面那么严格的检查。
// 
// 版本控制命令限制仅适用于使用直接版本
// 控制下载代码的访问权限。从代理下载模块时，
// /'go get'使用代理协议，这是始终允许的。
// 默认情况下，“go get”命令将go模块镜像（proxy.golang.org）
// 用于公共软件包，并且仅在私有
// 软件包或镜像拒绝为公共软件包提供服务时（通常是出于
// 法律原因）返回版本控制。因此，默认情况下，客户端仍然可以访问从
// Bazaar、Fossil或Subversion存储库提供的公共代码，因为那些下载
// 的用户使用Go模块镜像，这承担了运行
// 使用自定义沙盒的版本控制命令。
// 
// GOVCS变量可用于更改特定软件包（由模块或导入路径标识）允许的版本控制系统
// 。
// 在模块感知模式
// 和GOPATH模式下构建包时，GOVCS变量均适用。使用模块时，模式与模块路径匹配。
// 使用GOPATH时，模式与版本控制存储库根目录
// 对应的导入路径匹配。
// 
// GOVCS设置的一般形式是一个逗号分隔的
// pattern:vcslist规则列表。模式是一个全局模式，必须与
// 模块或导入路径的一个或多个前导元素匹配。vcslist 
// 是允许的版本控制命令的管道分隔列表，或“all”
// 以允许使用任何已知命令，或“off”以禁止所有命令。
// 请注意，如果模块匹配vcslist为“off”的模式，则如果源服务器使用“mod”方案，则仍可能是
// 下载，该方案指示
// go命令使用GOPROXY协议下载模块。
// 列表中最早的匹配模式适用，即使以后的模式也可能匹配。例如，考虑一下：
// 
// GOVCS=github。com:git，邪恶。com:off，*：git | hg 
// 
// 使用此设置，使用以
// github开头的模块或导入路径编码。com/只能使用git；邪恶之路。com不能使用任何版本的
// 控制命令，所有其他路径（*匹配所有内容）只能使用
// 仅git或hg。
// 
// 特殊模式“public”和“private”匹配public和private 
// 模块或导入路径。如果路径匹配GOPRIVATE 
// 变量，则该路径为私有路径；否则它是公开的。
// 
// 如果GOVCS变量中没有与特定模块或导入路径匹配的规则，
// go get命令将应用其默认规则，现在可以在GOVCS符号中总结为“public:git | hg，private:all”。
// 
// 要允许对任何包不受限制地使用任何版本控制系统，请使用：
// 
// GOVCS=*：all 
// 
// 禁用所有版本控制，用法：
// 
// GOVCS=*：off 
// 
// 可以使用'go env-w'命令（请参阅'go help env'）为将来的go命令调用设置GOVCS 
// 变量。
// 
// 
package main
